@omnizap-system/omnizap 2.5.12

package/server/controllers/admin/stickerCatalogAdminContext.js

@@ -0,0 +1,17 @@
+import { createStickerCatalogAdminBanService } from './adminBanService.js';
+import { createStickerCatalogAdminHandlers } from './adminPanelHandlers.js';
+
+export const createStickerCatalogAdminBanContext = (dependencies = {}) => {
+  const service = createStickerCatalogAdminBanService(dependencies);
+  const { listAdminBans, createAdminBanRecord, revokeAdminBanRecord, assertGoogleIdentityNotBanned } = service;
+
+  return {
+    service,
+    listAdminBans,
+    createAdminBanRecord,
+    revokeAdminBanRecord,
+    assertGoogleIdentityNotBanned,
+  };
+};
+
+export const createStickerCatalogAdminHandlersContext = (dependencies = {}) => createStickerCatalogAdminHandlers(dependencies);

package/server/controllers/admin/systemAdminController.js

@@ -0,0 +1,201 @@
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { URL } from 'node:url';
+
+import logger from '#logger';
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const normalizeBasePath = (value, fallback) => {
+  const raw = String(value || '').trim() || fallback;
+  const withLeadingSlash = raw.startsWith('/') ? raw : `/${raw}`;
+  const withoutTrailingSlash = withLeadingSlash.length > 1 && withLeadingSlash.endsWith('/') ? withLeadingSlash.slice(0, -1) : withLeadingSlash;
+  return withoutTrailingSlash || fallback;
+};
+
+const LEGACY_STICKER_API_BASE_PATH = normalizeBasePath(process.env.STICKER_API_BASE_PATH, '/api/sticker-packs');
+const USER_API_BASE_PATH = normalizeBasePath(process.env.USER_API_BASE_PATH || process.env.AUTH_API_BASE_PATH, '/api');
+const SYSTEM_ADMIN_API_BASE_PATH = normalizeBasePath(process.env.SYSTEM_ADMIN_API_BASE_PATH || `${USER_API_BASE_PATH}/admin`, `${USER_API_BASE_PATH}/admin`);
+const SYSTEM_ADMIN_API_SESSION_PATH = `${SYSTEM_ADMIN_API_BASE_PATH}/session`;
+const LEGACY_SYSTEM_ADMIN_API_BASE_PATH = `${LEGACY_STICKER_API_BASE_PATH}/admin`;
+const LEGACY_SYSTEM_ADMIN_API_SESSION_PATH = `${LEGACY_SYSTEM_ADMIN_API_BASE_PATH}/session`;
+const STICKER_LOGIN_WEB_PATH = normalizeBasePath(process.env.STICKER_LOGIN_WEB_PATH, '/login');
+const STICKER_WEB_PATH = normalizeBasePath(process.env.STICKER_WEB_PATH, '/stickers');
+const STICKER_ADMIN_WEB_PATH = `${STICKER_WEB_PATH}/admin`;
+const USER_PROFILE_WEB_PATH = normalizeBasePath(process.env.USER_PROFILE_WEB_PATH, '/user');
+const USER_SYSTEMADM_WEB_PATH = `${USER_PROFILE_WEB_PATH}/systemadm`;
+const STICKER_ADMIN_REDIRECT_TO_USER = parseEnvBool(process.env.STICKER_ADMIN_REDIRECT_TO_USER, true);
+const SITE_ORIGIN = String(process.env.SITE_ORIGIN || 'https://omnizap.shop')
+  .trim()
+  .replace(/\/+$/, '');
+
+const USER_SYSTEMADM_TEMPLATE_PATH = path.join(process.cwd(), 'public', 'pages', 'user-systemadm.html');
+const LEGACY_STICKER_ADMIN_TEMPLATE_PATH = path.join(process.cwd(), 'public', 'pages', 'stickers-admin.html');
+
+let stickerCatalogControllerPromise = null;
+const loadStickerCatalogController = async () => {
+  if (!stickerCatalogControllerPromise) {
+    stickerCatalogControllerPromise = import('../sticker/stickerCatalogController.js');
+  }
+  return stickerCatalogControllerPromise;
+};
+
+const sendHtml = (req, res, html) => {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'text/html; charset=utf-8');
+  res.setHeader('Cache-Control', 'no-store');
+  res.setHeader('X-Robots-Tag', 'noindex, nofollow');
+  if (req.method === 'HEAD') {
+    res.end();
+    return;
+  }
+  res.end(html);
+};
+
+const sendJson = (req, res, statusCode, payload) => {
+  const body = JSON.stringify(payload);
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'application/json; charset=utf-8');
+  res.setHeader('Cache-Control', 'no-store');
+  res.setHeader('X-Robots-Tag', 'noindex, nofollow');
+  if (req.method === 'HEAD') {
+    res.end();
+    return;
+  }
+  res.end(body);
+};
+
+const sendRedirect = (res, location) => {
+  res.statusCode = 302;
+  res.setHeader('Location', location);
+  res.setHeader('Cache-Control', 'no-store');
+  res.end();
+};
+
+const hasPathPrefix = (pathname, prefix) => pathname === prefix || pathname.startsWith(`${prefix}/`);
+const escapeHtmlAttribute = (value) =>
+  String(value || '')
+    .replace(/&/g, '&')
+    .replace(/"/g, '"')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+const replaceDataAttribute = (html, attributeName, value) => String(html || '').replace(new RegExp(`(${attributeName}=")([^"]*)(")`, 'i'), `$1${escapeHtmlAttribute(value)}$3`);
+const remapUrlPathname = (url, pathname) => {
+  if (!url || !pathname) return url;
+  try {
+    const remappedUrl = new URL(String(url?.href || url));
+    remappedUrl.pathname = pathname;
+    return remappedUrl;
+  } catch {
+    return url;
+  }
+};
+
+const mapAdminApiPathToLegacy = (pathname) => {
+  if (hasPathPrefix(pathname, SYSTEM_ADMIN_API_BASE_PATH)) {
+    const suffix = pathname.slice(SYSTEM_ADMIN_API_BASE_PATH.length);
+    return `${LEGACY_SYSTEM_ADMIN_API_BASE_PATH}${suffix || ''}`;
+  }
+  if (hasPathPrefix(pathname, LEGACY_SYSTEM_ADMIN_API_BASE_PATH)) {
+    return pathname;
+  }
+  return null;
+};
+
+const renderUserSystemAdminHtml = async () => {
+  const template = await fs.readFile(USER_SYSTEMADM_TEMPLATE_PATH, 'utf8');
+  const dataAttributes = {
+    'data-api-base-path': USER_API_BASE_PATH,
+    'data-login-path': STICKER_LOGIN_WEB_PATH,
+    'data-stickers-path': STICKER_WEB_PATH,
+  };
+
+  let html = template;
+  for (const [attributeName, value] of Object.entries(dataAttributes)) {
+    html = replaceDataAttribute(html, attributeName, value);
+  }
+
+  return html;
+};
+
+export const getSystemAdminRouteConfig = () => ({
+  webPath: USER_SYSTEMADM_WEB_PATH,
+  legacyWebPath: STICKER_ADMIN_WEB_PATH,
+  apiAdminBasePath: SYSTEM_ADMIN_API_BASE_PATH,
+  apiAdminSessionPath: SYSTEM_ADMIN_API_SESSION_PATH,
+  legacyApiAdminBasePath: LEGACY_SYSTEM_ADMIN_API_BASE_PATH,
+  legacyApiAdminSessionPath: LEGACY_SYSTEM_ADMIN_API_SESSION_PATH,
+});
+
+export const maybeHandleSystemAdminRequest = async (req, res, { pathname, url }) => {
+  if (!['GET', 'HEAD', 'POST', 'PATCH', 'DELETE'].includes(req.method || '')) return false;
+
+  if (pathname === USER_SYSTEMADM_WEB_PATH || pathname === `${USER_SYSTEMADM_WEB_PATH}/`) {
+    if (!['GET', 'HEAD'].includes(req.method || '')) return false;
+    try {
+      const html = await renderUserSystemAdminHtml();
+      sendHtml(req, res, html);
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        sendJson(req, res, 404, { error: 'Template da pagina system admin nao encontrado.' });
+        return true;
+      }
+      logger.error('Falha ao renderizar pagina system admin.', {
+        action: 'user_system_admin_page_render_failed',
+        path: pathname,
+        error: error?.message,
+      });
+      sendJson(req, res, 500, { error: 'Falha interna ao renderizar pagina system admin.' });
+    }
+    return true;
+  }
+
+  if (pathname === STICKER_ADMIN_WEB_PATH || pathname === `${STICKER_ADMIN_WEB_PATH}/`) {
+    if (!['GET', 'HEAD'].includes(req.method || '')) return false;
+    if (STICKER_ADMIN_REDIRECT_TO_USER) {
+      const requestUrl = new URL(req.url || `${STICKER_ADMIN_WEB_PATH}/`, SITE_ORIGIN);
+      const userUrl = new URL(`${USER_SYSTEMADM_WEB_PATH}/`, SITE_ORIGIN);
+      for (const [key, value] of requestUrl.searchParams.entries()) {
+        userUrl.searchParams.append(key, value);
+      }
+      sendRedirect(res, `${userUrl.pathname}${userUrl.search}`);
+      return true;
+    }
+    try {
+      const html = await fs.readFile(LEGACY_STICKER_ADMIN_TEMPLATE_PATH, 'utf8');
+      sendHtml(req, res, html);
+    } catch (error) {
+      if (error?.code === 'ENOENT') {
+        sendJson(req, res, 404, { error: 'Template do painel admin nao encontrado.' });
+        return true;
+      }
+      logger.error('Falha ao renderizar pagina admin legado.', {
+        action: 'legacy_sticker_admin_page_render_failed',
+        path: pathname,
+        error: error?.message,
+      });
+      sendJson(req, res, 500, { error: 'Falha interna ao renderizar painel admin.' });
+    }
+    return true;
+  }
+
+  if (hasPathPrefix(pathname, SYSTEM_ADMIN_API_BASE_PATH) || hasPathPrefix(pathname, LEGACY_SYSTEM_ADMIN_API_BASE_PATH)) {
+    const legacyPathname = mapAdminApiPathToLegacy(pathname);
+    if (!legacyPathname) return false;
+
+    const controller = await loadStickerCatalogController();
+    if (typeof controller?.maybeHandleStickerCatalogRequest !== 'function') return false;
+    return controller.maybeHandleStickerCatalogRequest(req, res, {
+      pathname: legacyPathname,
+      url: remapUrlPathname(url, legacyPathname),
+    });
+  }
+
+  return false;
+};

package/server/controllers/email/emailAutomationController.js

@@ -0,0 +1,239 @@
+import logger from '#logger';
+import { getEmailAutomationStatusSnapshot, queueAutomatedEmail } from '../../email/emailAutomationService.js';
+import { isEmailAutomationRuntimeEnabled, isEmailAutomationRuntimeRunning } from '../../email/emailAutomationRuntime.js';
+import { getEmailTransportMetadata } from '../../email/emailTransportService.js';
+
+const parseEnvBool = (value, fallback) => {
+  if (value === undefined || value === null || value === '') return fallback;
+  const normalized = String(value).trim().toLowerCase();
+  if (['1', 'true', 'yes', 'y', 'on'].includes(normalized)) return true;
+  if (['0', 'false', 'no', 'n', 'off'].includes(normalized)) return false;
+  return fallback;
+};
+
+const normalizeBasePath = (value, fallback) => {
+  const raw = String(value || '').trim() || fallback;
+  const withLeadingSlash = raw.startsWith('/') ? raw : `/${raw}`;
+  const withoutTrailingSlash = withLeadingSlash.length > 1 && withLeadingSlash.endsWith('/') ? withLeadingSlash.slice(0, -1) : withLeadingSlash;
+  return withoutTrailingSlash || fallback;
+};
+
+const EMAIL_AUTOMATION_API_BASE_PATH = normalizeBasePath(process.env.EMAIL_AUTOMATION_API_BASE_PATH, '/api/email');
+const EMAIL_AUTOMATION_API_KEY =
+  String(process.env.EMAIL_AUTOMATION_API_KEY || '')
+    .trim()
+    .slice(0, 255) || '';
+const EMAIL_AUTOMATION_REQUIRE_API_KEY = parseEnvBool(process.env.EMAIL_AUTOMATION_REQUIRE_API_KEY, true);
+const EMAIL_AUTOMATION_HEALTH_PUBLIC = parseEnvBool(process.env.EMAIL_AUTOMATION_HEALTH_PUBLIC, false);
+
+const sendJson = (req, res, statusCode, payload) => {
+  if (res.writableEnded) return true;
+  const body = JSON.stringify(payload);
+  res.statusCode = statusCode;
+  res.setHeader('Content-Type', 'application/json; charset=utf-8');
+  res.setHeader('Cache-Control', 'no-store');
+  if (req.method === 'HEAD') {
+    res.end();
+    return true;
+  }
+  res.end(body);
+  return true;
+};
+
+const readJsonBody = async (req, { maxBytes = 256 * 1024 } = {}) =>
+  new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+
+    req.on('data', (chunk) => {
+      total += chunk.length;
+      if (total > maxBytes) {
+        const error = new Error('Payload excedeu limite permitido.');
+        error.statusCode = 413;
+        reject(error);
+        req.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    });
+
+    req.on('end', () => {
+      const raw = Buffer.concat(chunks).toString('utf8').trim();
+      if (!raw) {
+        resolve({});
+        return;
+      }
+
+      try {
+        resolve(JSON.parse(raw));
+      } catch {
+        const error = new Error('JSON inválido.');
+        error.statusCode = 400;
+        reject(error);
+      }
+    });
+
+    req.on('error', (error) => reject(error));
+  });
+
+const resolveApiKeyFromRequest = (req) => {
+  const headerKey = String(req.headers?.['x-email-api-key'] || '').trim();
+  if (headerKey) return headerKey;
+
+  const authHeader = String(req.headers?.authorization || '').trim();
+  if (!authHeader.toLowerCase().startsWith('bearer ')) return '';
+  return authHeader.slice(7).trim();
+};
+
+const assertAuthorized = (req) => {
+  if (!EMAIL_AUTOMATION_REQUIRE_API_KEY) return;
+
+  if (!EMAIL_AUTOMATION_API_KEY) {
+    const error = new Error('EMAIL_AUTOMATION_API_KEY não configurada no servidor.');
+    error.statusCode = 503;
+    error.code = 'email_api_key_not_configured';
+    throw error;
+  }
+
+  const requestKey = resolveApiKeyFromRequest(req);
+  if (!requestKey || requestKey !== EMAIL_AUTOMATION_API_KEY) {
+    const error = new Error('Não autorizado.');
+    error.statusCode = 401;
+    error.code = 'email_api_key_invalid';
+    throw error;
+  }
+};
+
+export const getEmailAutomationRouteConfig = () => ({
+  apiBasePath: EMAIL_AUTOMATION_API_BASE_PATH,
+});
+
+export const maybeHandleEmailAutomationRequest = async (req, res, { pathname }) => {
+  if (!['GET', 'HEAD', 'POST'].includes(req.method || '')) return false;
+
+  const healthPath = `${EMAIL_AUTOMATION_API_BASE_PATH}/health`;
+  const statsPath = `${EMAIL_AUTOMATION_API_BASE_PATH}/stats`;
+  const enqueuePath = `${EMAIL_AUTOMATION_API_BASE_PATH}/enqueue`;
+  const testPath = `${EMAIL_AUTOMATION_API_BASE_PATH}/test`;
+
+  try {
+    if (pathname === healthPath) {
+      if (!['GET', 'HEAD'].includes(req.method || '')) {
+        return sendJson(req, res, 405, { error: 'Method Not Allowed' });
+      }
+
+      if (!EMAIL_AUTOMATION_HEALTH_PUBLIC) {
+        assertAuthorized(req);
+      }
+
+      const basePayload = {
+        ok: true,
+        runtime_enabled: isEmailAutomationRuntimeEnabled(),
+        runtime_running: isEmailAutomationRuntimeRunning(),
+        api_key_required: EMAIL_AUTOMATION_REQUIRE_API_KEY,
+      };
+
+      if (EMAIL_AUTOMATION_HEALTH_PUBLIC) {
+        return sendJson(req, res, 200, basePayload);
+      }
+
+      return sendJson(req, res, 200, {
+        ...basePayload,
+        api_base_path: EMAIL_AUTOMATION_API_BASE_PATH,
+        transport: getEmailTransportMetadata(),
+      });
+    }
+
+    if (pathname === statsPath) {
+      if (!['GET', 'HEAD'].includes(req.method || '')) {
+        return sendJson(req, res, 405, { error: 'Method Not Allowed' });
+      }
+      assertAuthorized(req);
+
+      const snapshot = await getEmailAutomationStatusSnapshot();
+      return sendJson(req, res, 200, {
+        ok: true,
+        ...snapshot,
+      });
+    }
+
+    if (pathname === enqueuePath) {
+      if (req.method !== 'POST') {
+        return sendJson(req, res, 405, { error: 'Method Not Allowed' });
+      }
+      assertAuthorized(req);
+
+      const body = await readJsonBody(req);
+      const queued = await queueAutomatedEmail({
+        to: body.to,
+        name: body.name,
+        templateKey: body.templateKey,
+        templateData: body.templateData,
+        subject: body.subject,
+        text: body.text,
+        html: body.html,
+        metadata: body.metadata,
+        priority: body.priority,
+        scheduledAt: body.scheduledAt,
+        maxAttempts: body.maxAttempts,
+        idempotencyKey: body.idempotencyKey,
+      });
+
+      return sendJson(req, res, 202, {
+        ok: true,
+        queued,
+      });
+    }
+
+    if (pathname === testPath) {
+      if (req.method !== 'POST') {
+        return sendJson(req, res, 405, { error: 'Method Not Allowed' });
+      }
+      assertAuthorized(req);
+
+      const body = await readJsonBody(req);
+      const testRecipient = String(body.to || '').trim();
+      const testName = String(body.name || 'Usuário OmniZap').trim();
+
+      const queued = await queueAutomatedEmail({
+        to: testRecipient,
+        name: testName,
+        templateKey: 'welcome',
+        templateData: {
+          name: testName,
+          loginUrl: body.loginUrl,
+          redirectUrl: body.redirectUrl,
+          homeUrl: body.homeUrl,
+          siteOrigin: body.siteOrigin,
+        },
+        metadata: {
+          trigger: 'email_api_test',
+        },
+        idempotencyKey: body.idempotencyKey,
+      });
+
+      return sendJson(req, res, 202, {
+        ok: true,
+        queued,
+      });
+    }
+
+    return false;
+  } catch (error) {
+    const statusCode = Number(error?.statusCode || 500);
+
+    if (statusCode >= 500) {
+      logger.error('Falha no controller de automação de e-mail.', {
+        action: 'email_automation_controller_failed',
+        path: pathname,
+        method: req.method,
+        error: error?.message,
+      });
+    }
+
+    return sendJson(req, res, statusCode, {
+      error: error?.message || 'Falha interna ao processar requisição de e-mail.',
+      code: error?.code || null,
+    });
+  }
+};

package/server/controllers/metricsController.js

@@ -0,0 +1,21 @@
+import logger from '#logger';
+import { getMetricsPayload } from '../../app/observability/metrics.js';
+
+export const sendMetricsResponse = async (res) => {
+  try {
+    const payload = await getMetricsPayload();
+    if (!payload) {
+      res.statusCode = 404;
+      res.end('Not Found');
+      return;
+    }
+
+    res.statusCode = 200;
+    res.setHeader('Content-Type', payload.contentType);
+    res.end(payload.body);
+  } catch (error) {
+    res.statusCode = 500;
+    res.end('Metrics error');
+    logger.error('Erro ao gerar /metrics', { error: error?.message });
+  }
+};