@kaikybrofc/omnizap-system 2.2.10 → 2.3.1

package/app/modules/stickerPackModule/stickerPackService.js

@@ -187,28 +187,9 @@ export function createStickerPackService(options = {}) {
   const hasOwnerPackLimit = Number.isFinite(maxPacksPerOwner);
   const runInTransaction = options.runInTransaction || withTransaction;
 
-  const requiredPackMethods = [
-    'createStickerPack',
-    'listStickerPacksByOwner',
-    'findStickerPackByOwnerAndIdentifier',
-    'findStickerPackByPackKey',
-    'updateStickerPackFields',
-    'softDeleteStickerPack',
-    'ensureUniquePackKey',
-    'bumpStickerPackVersion',
-  ];
-
-  const requiredItemMethods = [
-    'listStickerPackItems',
-    'countStickerPackItems',
-    'getMaxStickerPackPosition',
-    'createStickerPackItem',
-    'getStickerPackItemByStickerId',
-    'getStickerPackItemByPosition',
-    'removeStickerPackItemByStickerId',
-    'shiftStickerPackPositionsAfter',
-    'bulkUpdateStickerPackPositions',
-  ];
+  const requiredPackMethods = ['createStickerPack', 'listStickerPacksByOwner', 'findStickerPackByOwnerAndIdentifier', 'findStickerPackByPackKey', 'updateStickerPackFields', 'softDeleteStickerPack', 'ensureUniquePackKey', 'bumpStickerPackVersion'];
+
+  const requiredItemMethods = ['listStickerPackItems', 'countStickerPackItems', 'getMaxStickerPackPosition', 'createStickerPackItem', 'getStickerPackItemByStickerId', 'getStickerPackItemByPosition', 'removeStickerPackItemByStickerId', 'shiftStickerPackPositionsAfter', 'bulkUpdateStickerPackPositions'];
 
   for (const methodName of requiredPackMethods) {
     if (typeof deps.packRepository[methodName] !== 'function') {
@@ -224,11 +205,7 @@ export function createStickerPackService(options = {}) {
 
   const runAction = async (action, context, handler, { expectedErrorCodes = [] } = {}) => {
     const start = process.hrtime.bigint();
-    const expectedCodesSet = new Set(
-      Array.isArray(expectedErrorCodes)
-        ? expectedErrorCodes.map((code) => String(code || '').trim()).filter(Boolean)
-        : [],
-    );
+    const expectedCodesSet = new Set(Array.isArray(expectedErrorCodes) ? expectedErrorCodes.map((code) => String(code || '').trim()).filter(Boolean) : []);
 
     try {
       const result = await handler();
@@ -343,9 +320,7 @@ export function createStickerPackService(options = {}) {
   const loadPackDetails = async (pack, { connection = null } = {}) => {
     const items = await deps.itemRepository.listStickerPackItems(pack.id, connection);
     const coverItem = items.find((item) => item.sticker_id === pack.cover_sticker_id);
-    const packClassification = await getPackClassificationSummaryByAssetIds(items.map((item) => item.sticker_id)).catch(
-      () => null,
-    );
+    const packClassification = await getPackClassificationSummaryByAssetIds(items.map((item) => item.sticker_id)).catch(() => null);
 
     return {
       ...pack,
@@ -373,23 +348,9 @@ export function createStickerPackService(options = {}) {
     };
   };
 
-  const createPack = async ({
-    ownerJid,
-    name,
-    publisher,
-    description,
-    visibility = 'public',
-    status = 'published',
-    packStatus = undefined,
-    packThemeKey = undefined,
-    packVolume = undefined,
-    isAutoPack = undefined,
-    lastRebalancedAt = undefined,
-  }) => {
+  const createPack = async ({ ownerJid, name, publisher, description, visibility = 'public', status = 'published', packStatus = undefined, packThemeKey = undefined, packVolume = undefined, isAutoPack = undefined, lastRebalancedAt = undefined }) => {
     const owner = resolveOwner(ownerJid);
-    const normalizedStatus = PACK_STATUS_VALUES.has(String(status || '').toLowerCase())
-      ? String(status).toLowerCase()
-      : 'published';
+    const normalizedStatus = PACK_STATUS_VALUES.has(String(status || '').toLowerCase()) ? String(status).toLowerCase() : 'published';
 
     return runAction('create_pack', { owner_jid: owner }, async () => {
       return runInTransaction(async (connection) => {
@@ -400,11 +361,7 @@ export function createStickerPackService(options = {}) {
             connection,
           });
 
-          ensureValue(
-            existing.length < maxPacksPerOwner,
-            STICKER_PACK_ERROR_CODES.PACK_LIMIT_REACHED,
-            `Limite de packs atingido (${maxPacksPerOwner}).`,
-          );
+          ensureValue(existing.length < maxPacksPerOwner, STICKER_PACK_ERROR_CODES.PACK_LIMIT_REACHED, `Limite de packs atingido (${maxPacksPerOwner}).`);
         }
 
         const packKey = await ensurePackKey(owner, metadata.name, connection);
@@ -507,11 +464,7 @@ export function createStickerPackService(options = {}) {
     const owner = resolveOwner(ownerJid);
     const normalizedVisibility = toVisibility(visibility, null);
 
-    ensureValue(
-      normalizedVisibility,
-      STICKER_PACK_ERROR_CODES.INVALID_INPUT,
-      'Visibilidade inválida. Use: private, public ou unlisted.',
-    );
+    ensureValue(normalizedVisibility, STICKER_PACK_ERROR_CODES.INVALID_INPUT, 'Visibilidade inválida. Use: private, public ou unlisted.');
 
     return runAction('set_visibility', { owner_jid: owner }, async () => {
       const pack = await resolveOwnedPack(owner, identifier);
@@ -542,14 +495,7 @@ export function createStickerPackService(options = {}) {
     });
   };
 
-  const addStickerToPack = async ({
-    ownerJid,
-    identifier,
-    asset,
-    emojis = [],
-    accessibilityLabel = null,
-    expectedErrorCodes = [],
-  }) => {
+  const addStickerToPack = async ({ ownerJid, identifier, asset, emojis = [], accessibilityLabel = null, expectedErrorCodes = [] }) => {
     const owner = resolveOwner(ownerJid);
 
     ensureValue(asset?.id, STICKER_PACK_ERROR_CODES.STICKER_NOT_FOUND, 'Nenhuma figurinha válida foi encontrada.');
@@ -558,57 +504,54 @@ export function createStickerPackService(options = {}) {
       allowEmpty: true,
     });
 
-    return runAction('add_sticker', { owner_jid: owner }, async () => {
-      const pack = await resolveOwnedPack(owner, identifier);
+    return runAction(
+      'add_sticker',
+      { owner_jid: owner },
+      async () => {
+        const pack = await resolveOwnedPack(owner, identifier);
 
-      return runInTransaction(async (connection) => {
-        const existingItem = await deps.itemRepository.getStickerPackItemByStickerId(pack.id, asset.id, connection);
-        ensureValue(
-          !existingItem,
-          STICKER_PACK_ERROR_CODES.DUPLICATE_STICKER,
-          'Essa figurinha já está no pack.',
-        );
+        return runInTransaction(async (connection) => {
+          const existingItem = await deps.itemRepository.getStickerPackItemByStickerId(pack.id, asset.id, connection);
+          ensureValue(!existingItem, STICKER_PACK_ERROR_CODES.DUPLICATE_STICKER, 'Essa figurinha já está no pack.');
 
-        const total = await deps.itemRepository.countStickerPackItems(pack.id, connection);
-        ensureValue(
-          total < maxStickersPerPack,
-          STICKER_PACK_ERROR_CODES.PACK_LIMIT_REACHED,
-          `O pack atingiu o limite de ${maxStickersPerPack} figurinhas.`,
-        );
+          const total = await deps.itemRepository.countStickerPackItems(pack.id, connection);
+          ensureValue(total < maxStickersPerPack, STICKER_PACK_ERROR_CODES.PACK_LIMIT_REACHED, `O pack atingiu o limite de ${maxStickersPerPack} figurinhas.`);
 
-        const maxPosition = await deps.itemRepository.getMaxStickerPackPosition(pack.id, connection);
+          const maxPosition = await deps.itemRepository.getMaxStickerPackPosition(pack.id, connection);
 
-        await deps.itemRepository.createStickerPackItem(
-          {
-            id: randomUUID(),
-            pack_id: pack.id,
-            sticker_id: asset.id,
-            position: maxPosition + 1,
-            emojis: parseEmojiList(emojis),
-            accessibility_label: normalizedLabel || null,
-          },
-          connection,
-        );
-
-        if (!pack.cover_sticker_id) {
-          await deps.packRepository.updateStickerPackFields(
-            pack.id,
+          await deps.itemRepository.createStickerPackItem(
             {
-              cover_sticker_id: asset.id,
+              id: randomUUID(),
+              pack_id: pack.id,
+              sticker_id: asset.id,
+              position: maxPosition + 1,
+              emojis: parseEmojiList(emojis),
+              accessibility_label: normalizedLabel || null,
             },
             connection,
           );
-        } else {
-          await deps.packRepository.bumpStickerPackVersion(pack.id, connection);
-        }
 
-        const reloaded = await deps.packRepository.findStickerPackByOwnerAndIdentifier(owner, pack.id, {
-          connection,
-        });
+          if (!pack.cover_sticker_id) {
+            await deps.packRepository.updateStickerPackFields(
+              pack.id,
+              {
+                cover_sticker_id: asset.id,
+              },
+              connection,
+            );
+          } else {
+            await deps.packRepository.bumpStickerPackVersion(pack.id, connection);
+          }
+
+          const reloaded = await deps.packRepository.findStickerPackByOwnerAndIdentifier(owner, pack.id, {
+            connection,
+          });
 
-        return loadPackDetails(reloaded, { connection });
-      });
-    }, { expectedErrorCodes });
+          return loadPackDetails(reloaded, { connection });
+        });
+      },
+      { expectedErrorCodes },
+    );
   };
 
   const removeStickerFromPack = async ({ ownerJid, identifier, selector }) => {
@@ -665,11 +608,7 @@ export function createStickerPackService(options = {}) {
 
   const reorderPackItems = async ({ ownerJid, identifier, orderStickerIds }) => {
     const owner = resolveOwner(ownerJid);
-    ensureValue(
-      Array.isArray(orderStickerIds) && orderStickerIds.length > 0,
-      STICKER_PACK_ERROR_CODES.INVALID_INPUT,
-      'Envie a nova ordem de figurinhas.',
-    );
+    ensureValue(Array.isArray(orderStickerIds) && orderStickerIds.length > 0, STICKER_PACK_ERROR_CODES.INVALID_INPUT, 'Envie a nova ordem de figurinhas.');
 
     return runAction('reorder_pack', { owner_jid: owner }, async () => {
       const pack = await resolveOwnedPack(owner, identifier);
@@ -690,11 +629,7 @@ export function createStickerPackService(options = {}) {
           seen.add(id);
         }
 
-        ensureValue(
-          requestedIds.length > 0,
-          STICKER_PACK_ERROR_CODES.INVALID_INPUT,
-          'A ordem enviada não corresponde às figurinhas do pack.',
-        );
+        ensureValue(requestedIds.length > 0, STICKER_PACK_ERROR_CODES.INVALID_INPUT, 'A ordem enviada não corresponde às figurinhas do pack.');
 
         const finalOrder = [...requestedIds, ...currentIds.filter((id) => !seen.has(id))];
 

package/app/modules/stickerPackModule/stickerPackServiceRuntime.js

@@ -1,25 +1,6 @@
 import { createStickerPackService } from './stickerPackService.js';
-import {
-  bumpStickerPackVersion,
-  createStickerPack,
-  ensureUniquePackKey,
-  findStickerPackByPackKey,
-  findStickerPackByOwnerAndIdentifier,
-  listStickerPacksByOwner,
-  softDeleteStickerPack,
-  updateStickerPackFields,
-} from './stickerPackRepository.js';
-import {
-  bulkUpdateStickerPackPositions,
-  countStickerPackItems,
-  createStickerPackItem,
-  getMaxStickerPackPosition,
-  getStickerPackItemByPosition,
-  getStickerPackItemByStickerId,
-  listStickerPackItems,
-  removeStickerPackItemByStickerId,
-  shiftStickerPackPositionsAfter,
-} from './stickerPackItemRepository.js';
+import { bumpStickerPackVersion, createStickerPack, ensureUniquePackKey, findStickerPackByPackKey, findStickerPackByOwnerAndIdentifier, listStickerPacksByOwner, softDeleteStickerPack, updateStickerPackFields } from './stickerPackRepository.js';
+import { bulkUpdateStickerPackPositions, countStickerPackItems, createStickerPackItem, getMaxStickerPackPosition, getStickerPackItemByPosition, getStickerPackItemByStickerId, listStickerPackItems, removeStickerPackItemByStickerId, shiftStickerPackPositionsAfter } from './stickerPackItemRepository.js';
 
 /**
  * Serviço principal de sticker pack com dependências concretas de runtime.

package/app/modules/stickerPackModule/stickerPackUtils.js

@@ -54,7 +54,11 @@ export const slugify = (value, { fallback = 'pack', maxLength = 32 } = {}) => {
  * @param {number} [size=8] Quantidade de caracteres retornados.
  * @returns {string} Hash hexadecimal truncado.
  */
-export const shortHash = (value, size = 8) => createHash('sha256').update(String(value ?? '')).digest('hex').slice(0, size);
+export const shortHash = (value, size = 8) =>
+  createHash('sha256')
+    .update(String(value ?? ''))
+    .digest('hex')
+    .slice(0, size);
 
 /**
  * Normaliza o JID do dono mantendo fallback para o valor original.
@@ -72,7 +76,9 @@ export const normalizeOwnerJid = (jid) => normalizeJid(jid || '') || jid || '';
  * @returns {'private'|'public'|'unlisted'|null} Valor de visibilidade válido.
  */
 export const toVisibility = (value, fallback = 'private') => {
-  const normalized = String(value || '').trim().toLowerCase();
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
   if (normalized === 'public' || normalized === 'unlisted' || normalized === 'private') {
     return normalized;
   }
@@ -87,7 +93,11 @@ export const toVisibility = (value, fallback = 'private') => {
  */
 export const parseEmojiList = (value) => {
   if (!value) return [];
-  if (Array.isArray(value)) return value.map((item) => String(item)).filter(Boolean).slice(0, 8);
+  if (Array.isArray(value))
+    return value
+      .map((item) => String(item))
+      .filter(Boolean)
+      .slice(0, 8);
 
   return String(value)
     .split(',')

package/app/modules/stickerPackModule/stickerStorageService.js

@@ -5,22 +5,11 @@ import { createHash, randomUUID } from 'node:crypto';
 import logger from '../../utils/logger/loggerModule.js';
 import { downloadMediaMessage, extractMediaDetails } from '../../config/baileysConfig.js';
 import { isFeatureEnabled } from '../../services/featureFlagService.js';
-import {
-  createStickerAsset,
-  findLatestStickerAssetByOwner,
-  findStickerAssetById,
-  findStickerAssetBySha256,
-  updateStickerAssetStoragePath,
-} from './stickerAssetRepository.js';
+import { createStickerAsset, findLatestStickerAssetByOwner, findStickerAssetById, findStickerAssetBySha256, updateStickerAssetStoragePath } from './stickerAssetRepository.js';
 import { ensureStickerAssetClassified } from './stickerClassificationService.js';
 import { STICKER_PACK_ERROR_CODES, StickerPackError } from './stickerPackErrors.js';
 import { normalizeOwnerJid } from './stickerPackUtils.js';
-import {
-  getStickerObjectStorageUrl,
-  isStickerObjectStorageEnabled,
-  readStickerFromObjectStorage,
-  uploadStickerToObjectStorage,
-} from './stickerObjectStorageService.js';
+import { getStickerObjectStorageUrl, isStickerObjectStorageEnabled, readStickerFromObjectStorage, uploadStickerToObjectStorage } from './stickerObjectStorageService.js';
 
 /**
  * Camada de storage local para assets de figurinha do sistema de packs.
@@ -30,10 +19,7 @@ const TEMP_ROOT = path.join(process.cwd(), 'temp', 'sticker-pack-assets');
 const DEFAULT_MAX_STICKER_BYTES = 2 * 1024 * 1024;
 const MAX_STICKER_BYTES = Math.max(64 * 1024, Number(process.env.STICKER_PACK_MAX_STICKER_BYTES) || DEFAULT_MAX_STICKER_BYTES);
 const LAST_STICKER_TTL_MS = Math.max(60_000, Number(process.env.STICKER_PACK_LAST_CACHE_TTL_MS) || 6 * 60 * 60 * 1000);
-const OBJECT_STORAGE_UPLOAD_TIMEOUT_MS = Math.max(
-  1_000,
-  Number(process.env.STICKER_OBJECT_STORAGE_UPLOAD_TIMEOUT_MS) || 10_000,
-);
+const OBJECT_STORAGE_UPLOAD_TIMEOUT_MS = Math.max(1_000, Number(process.env.STICKER_OBJECT_STORAGE_UPLOAD_TIMEOUT_MS) || 10_000);
 
 const lastStickerCache = new Map();
 
@@ -61,7 +47,9 @@ const isObjectStorageDeliveryEnabled = async (subjectKey = '') =>
  */
 const safeOwnerToken = (ownerJid) => {
   const normalized = normalizeOwnerJid(ownerJid);
-  const token = String(normalized || 'unknown').replace(/[^a-zA-Z0-9._-]/g, '_').slice(0, 100);
+  const token = String(normalized || 'unknown')
+    .replace(/[^a-zA-Z0-9._-]/g, '_')
+    .slice(0, 100);
   return token || 'unknown';
 };
 
@@ -263,17 +251,11 @@ const validateStickerBuffer = (buffer) => {
   }
 
   if (buffer.length > MAX_STICKER_BYTES) {
-    throw new StickerPackError(
-      STICKER_PACK_ERROR_CODES.INVALID_INPUT,
-      `Figurinha excede o limite de ${(MAX_STICKER_BYTES / (1024 * 1024)).toFixed(1)} MB.`,
-    );
+    throw new StickerPackError(STICKER_PACK_ERROR_CODES.INVALID_INPUT, `Figurinha excede o limite de ${(MAX_STICKER_BYTES / (1024 * 1024)).toFixed(1)} MB.`);
   }
 
   if (!isLikelyWebp(buffer)) {
-    throw new StickerPackError(
-      STICKER_PACK_ERROR_CODES.INVALID_INPUT,
-      'A mídia precisa estar no formato WEBP para entrar no pack.',
-    );
+    throw new StickerPackError(STICKER_PACK_ERROR_CODES.INVALID_INPUT, 'A mídia precisa estar no formato WEBP para entrar no pack.');
   }
 };
 
@@ -390,10 +372,7 @@ async function persistStickerAssetFromDetails({ mediaDetails, ownerJid }) {
   const mediaSize = Number(mediaDetails?.details?.fileLength || mediaDetails?.mediaKey?.fileLength || 0);
 
   if (mediaSize > MAX_STICKER_BYTES) {
-    throw new StickerPackError(
-      STICKER_PACK_ERROR_CODES.INVALID_INPUT,
-      `Figurinha excede o limite de ${(MAX_STICKER_BYTES / (1024 * 1024)).toFixed(1)} MB.`,
-    );
+    throw new StickerPackError(STICKER_PACK_ERROR_CODES.INVALID_INPUT, `Figurinha excede o limite de ${(MAX_STICKER_BYTES / (1024 * 1024)).toFixed(1)} MB.`);
   }
 
   const tempOwnerDir = path.join(TEMP_ROOT, safeOwnerToken(normalizedOwner));
@@ -404,10 +383,7 @@ async function persistStickerAssetFromDetails({ mediaDetails, ownerJid }) {
   try {
     downloadedPath = await downloadMediaMessage(mediaDetails.mediaKey, 'sticker', tempOwnerDir);
     if (!downloadedPath) {
-      throw new StickerPackError(
-        STICKER_PACK_ERROR_CODES.STORAGE_ERROR,
-        'Não foi possível baixar a figurinha para armazenamento.',
-      );
+      throw new StickerPackError(STICKER_PACK_ERROR_CODES.STORAGE_ERROR, 'Não foi possível baixar a figurinha para armazenamento.');
     }
 
     const buffer = await fs.readFile(downloadedPath);
@@ -427,11 +403,7 @@ async function persistStickerAssetFromDetails({ mediaDetails, ownerJid }) {
       owner_jid: normalizedOwner,
       error: error.message,
     });
-    throw new StickerPackError(
-      STICKER_PACK_ERROR_CODES.STORAGE_ERROR,
-      'Falha ao salvar figurinha no servidor.',
-      error,
-    );
+    throw new StickerPackError(STICKER_PACK_ERROR_CODES.STORAGE_ERROR, 'Falha ao salvar figurinha no servidor.', error);
   } finally {
     if (downloadedPath) {
       await fs.unlink(downloadedPath).catch(() => {});
@@ -461,11 +433,7 @@ export async function saveStickerAssetFromBuffer({ ownerJid, buffer, mimetype =
       error: error.message,
     });
 
-    throw new StickerPackError(
-      STICKER_PACK_ERROR_CODES.STORAGE_ERROR,
-      'Falha ao salvar figurinha gerada no servidor.',
-      error,
-    );
+    throw new StickerPackError(STICKER_PACK_ERROR_CODES.STORAGE_ERROR, 'Falha ao salvar figurinha gerada no servidor.', error);
   }
 }
 
@@ -525,12 +493,7 @@ export async function getLastStickerAssetForOwner(ownerJid) {
  * }} params Contexto de resolução.
  * @returns {Promise<object|null>} Asset resolvido.
  */
-export async function resolveStickerAssetForCommand({
-  messageInfo,
-  ownerJid,
-  includeQuoted = true,
-  fallbackToLast = true,
-}) {
+export async function resolveStickerAssetForCommand({ messageInfo, ownerJid, includeQuoted = true, fallbackToLast = true }) {
   const mediaDetails = resolveStickerMediaDetails(messageInfo, { includeQuoted });
 
   if (mediaDetails) {
@@ -560,11 +523,7 @@ export async function readStickerAssetBuffer(asset) {
       if (Buffer.isBuffer(externalBuffer) && externalBuffer.length) {
         return externalBuffer;
       }
-      throw new StickerPackError(
-        STICKER_PACK_ERROR_CODES.STORAGE_ERROR,
-        `Não foi possível ler a figurinha em disco (${asset.storage_path}).`,
-        error,
-      );
+      throw new StickerPackError(STICKER_PACK_ERROR_CODES.STORAGE_ERROR, `Não foi possível ler a figurinha em disco (${asset.storage_path}).`, error);
     }
   }
 
@@ -576,17 +535,9 @@ export async function readStickerAssetBuffer(asset) {
   throw new StickerPackError(STICKER_PACK_ERROR_CODES.STORAGE_ERROR, 'Caminho do sticker não encontrado no storage.');
 }
 
-export async function getStickerAssetExternalUrl(
-  asset,
-  {
-    secure = true,
-    expiresInSeconds = 300,
-  } = {},
-) {
+export async function getStickerAssetExternalUrl(asset, { secure = true, expiresInSeconds = 300 } = {}) {
   if (!asset) return null;
-  const canUseExternalDelivery = await isObjectStorageDeliveryEnabled(
-    normalizeOwnerJid(asset?.owner_jid || '') || String(asset?.id || asset?.sha256 || ''),
-  );
+  const canUseExternalDelivery = await isObjectStorageDeliveryEnabled(normalizeOwnerJid(asset?.owner_jid || '') || String(asset?.id || asset?.sha256 || ''));
   if (!canUseExternalDelivery) return null;
   return getStickerObjectStorageUrl(asset, {
     secure,

package/app/modules/stickerPackModule/stickerWorkerPipelineRuntime.js

@@ -3,14 +3,7 @@ import { setQueueDepth } from '../../observability/metrics.js';
 import { isFeatureEnabled } from '../../services/featureFlagService.js';
 import { runStickerClassificationCycle } from './stickerClassificationBackgroundRuntime.js';
 import { runStickerAutoPackByTagsCycle } from './stickerAutoPackByTagsRuntime.js';
-import {
-  claimWorkerTask,
-  completeWorkerTask,
-  countWorkerTasksByStatus,
-  enqueueWorkerTask,
-  failWorkerTask,
-  hasPendingWorkerTask,
-} from './stickerWorkerTaskQueueRepository.js';
+import { claimWorkerTask, completeWorkerTask, countWorkerTasksByStatus, enqueueWorkerTask, failWorkerTask, hasPendingWorkerTask } from './stickerWorkerTaskQueueRepository.js';
 
 const parseEnvBool = (value, fallback) => {
   if (value === undefined || value === null || value === '') return fallback;
@@ -39,10 +32,7 @@ const TASK_PRIORITY = {
   curation_cycle: 55,
   rebuild_cycle: 50,
 };
-const PIPELINE_PROCESS_COHORT_KEY =
-  String(process.env.STICKER_WORKER_PIPELINE_COHORT_KEY || process.env.HOSTNAME || process.pid)
-    .trim()
-  || 'pipeline';
+const PIPELINE_PROCESS_COHORT_KEY = String(process.env.STICKER_WORKER_PIPELINE_COHORT_KEY || process.env.HOSTNAME || process.pid).trim() || 'pipeline';
 
 let startupHandle = null;
 let schedulerHandle = null;
@@ -59,11 +49,7 @@ const taskHandlers = {
 
 const refreshQueueDepthMetrics = async () => {
   if (!taskQueueAvailable) return;
-  const [pending, processing, failed] = await Promise.all([
-    countWorkerTasksByStatus('pending'),
-    countWorkerTasksByStatus('processing'),
-    countWorkerTasksByStatus('failed'),
-  ]);
+  const [pending, processing, failed] = await Promise.all([countWorkerTasksByStatus('pending'), countWorkerTasksByStatus('processing'), countWorkerTasksByStatus('failed')]);
   setQueueDepth('sticker_worker_tasks_pending', pending);
   setQueueDepth('sticker_worker_tasks_processing', processing);
   setQueueDepth('sticker_worker_tasks_failed', failed);
@@ -107,11 +93,7 @@ const schedulerTick = async () => {
   if (!PIPELINE_ENABLED) return;
 
   try {
-    await Promise.all([
-      scheduleTaskIfNeeded('classification_cycle'),
-      scheduleTaskIfNeeded('curation_cycle'),
-      scheduleTaskIfNeeded('rebuild_cycle'),
-    ]);
+    await Promise.all([scheduleTaskIfNeeded('classification_cycle'), scheduleTaskIfNeeded('curation_cycle'), scheduleTaskIfNeeded('rebuild_cycle')]);
     await refreshQueueDepthMetrics();
   } catch (error) {
     if (error?.code === 'ER_NO_SUCH_TABLE') {

package/app/modules/stickerPackModule/stickerWorkerTaskQueueRepository.js

@@ -3,13 +3,17 @@ import { randomUUID } from 'node:crypto';
 import { executeQuery, TABLES } from '../../../database/index.js';
 
 const normalizeTaskType = (value) => {
-  const normalized = String(value || '').trim().toLowerCase();
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
   if (['classification_cycle', 'curation_cycle', 'rebuild_cycle'].includes(normalized)) return normalized;
   return null;
 };
 
 const normalizeStatus = (value) => {
-  const normalized = String(value || '').trim().toLowerCase();
+  const normalized = String(value || '')
+    .trim()
+    .toLowerCase();
   if (['pending', 'processing', 'completed', 'failed'].includes(normalized)) return normalized;
   return null;
 };
@@ -20,12 +24,7 @@ const clampInt = (value, fallback, min, max) => {
   return Math.max(min, Math.min(max, Math.floor(numeric)));
 };
 
-const CLAIM_LOCK_TIMEOUT_SECONDS = clampInt(
-  process.env.STICKER_WORKER_TASK_LOCK_TIMEOUT_SECONDS,
-  15 * 60,
-  30,
-  24 * 60 * 60,
-);
+const CLAIM_LOCK_TIMEOUT_SECONDS = clampInt(process.env.STICKER_WORKER_TASK_LOCK_TIMEOUT_SECONDS, 15 * 60, 30, 24 * 60 * 60);
 
 const normalizeIdempotencyKey = (value) =>
   String(value || '')
@@ -76,10 +75,7 @@ const normalizeRow = (row) => {
   };
 };
 
-export async function enqueueWorkerTask(
-  { taskType, payload = {}, priority = 50, scheduledAt = null, maxAttempts = 5, idempotencyKey = '' },
-  connection = null,
-) {
+export async function enqueueWorkerTask({ taskType, payload = {}, priority = 50, scheduledAt = null, maxAttempts = 5, idempotencyKey = '' }, connection = null) {
   const normalizedTaskType = normalizeTaskType(taskType);
   if (!normalizedTaskType) return false;
 
@@ -99,14 +95,7 @@ export async function enqueueWorkerTask(
       scheduled_at = LEAST(scheduled_at, VALUES(scheduled_at)),
       status = IF(status = 'failed' AND attempts < max_attempts, 'pending', status),
       updated_at = UTC_TIMESTAMP()`,
-    [
-      normalizedTaskType,
-      normalizedIdempotencyKey,
-      JSON.stringify(payload || {}),
-      safePriority,
-      scheduledValue,
-      safeMaxAttempts,
-    ],
+    [normalizedTaskType, normalizedIdempotencyKey, JSON.stringify(payload || {}), safePriority, scheduledValue, safeMaxAttempts],
     connection,
   );
   return true;
@@ -196,17 +185,13 @@ export async function completeWorkerTask(taskId, connection = null) {
   return true;
 }
 
-export async function failWorkerTask(
-  taskId,
-  {
-    error = null,
-    retryDelaySeconds = 0,
-  } = {},
-  connection = null,
-) {
+export async function failWorkerTask(taskId, { error = null, retryDelaySeconds = 0 } = {}, connection = null) {
   if (!taskId) return false;
   const safeDelay = clampInt(retryDelaySeconds, 0, 0, 86400 * 7);
-  const message = String(error || '').trim().slice(0, 255) || null;
+  const message =
+    String(error || '')
+      .trim()
+      .slice(0, 255) || null;
 
   await executeQuery(
     `UPDATE ${TABLES.STICKER_WORKER_TASK_QUEUE}