@kaikybrofc/omnizap-system 2.1.8

package/app/utils/http/getImageBufferModule.js

@@ -0,0 +1,18 @@
+import https from 'node:https';
+
+const getImageBuffer = (url) =>
+  new Promise((resolve, reject) => {
+    https
+      .get(url, (response) => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`Failed to get image, status code: ${response.statusCode}`));
+          return;
+        }
+        const chunks = [];
+        response.on('data', (chunk) => chunks.push(chunk));
+        response.on('end', () => resolve(Buffer.concat(chunks)));
+      })
+      .on('error', (err) => reject(err));
+  });
+
+export default getImageBuffer;

package/app/utils/json/jsonSanitizer.js

@@ -0,0 +1,113 @@
+/**
+ * Sanitiza caracteres Unicode invalidos para JSON.
+ * Substitui surrogates "soltos" (sem par valido) por U+FFFD.
+ *
+ * @param {string} value
+ * @returns {string}
+ */
+export const sanitizeUnicodeString = (value) => {
+  if (typeof value !== 'string' || value.length === 0) {
+    return value;
+  }
+
+  if (!/[\uD800-\uDFFF]/.test(value)) {
+    return value;
+  }
+
+  let normalized = '';
+  for (let i = 0; i < value.length; i += 1) {
+    const code = value.charCodeAt(i);
+
+    if (code >= 0xd800 && code <= 0xdbff) {
+      const nextCode = value.charCodeAt(i + 1);
+      if (nextCode >= 0xdc00 && nextCode <= 0xdfff) {
+        normalized += value[i] + value[i + 1];
+        i += 1;
+      } else {
+        normalized += '\uFFFD';
+      }
+      continue;
+    }
+
+    if (code >= 0xdc00 && code <= 0xdfff) {
+      normalized += '\uFFFD';
+      continue;
+    }
+
+    normalized += value[i];
+  }
+
+  return normalized;
+};
+
+/**
+ * Cria replacer para JSON.stringify com suporte a:
+ * - strings com surrogate invalido
+ * - referencias circulares
+ * - bigint
+ * - numeros nao finitos
+ *
+ * @returns {(key:string, value:any)=>any}
+ */
+const createSafeJsonReplacer = () => {
+  const seen = new WeakSet();
+
+  return (_, value) => {
+    if (typeof value === 'string') {
+      return sanitizeUnicodeString(value);
+    }
+
+    if (typeof value === 'bigint') {
+      return value.toString();
+    }
+
+    if (typeof value === 'number' && !Number.isFinite(value)) {
+      return null;
+    }
+
+    if (value instanceof Date) {
+      return Number.isNaN(value.getTime()) ? null : value.toISOString();
+    }
+
+    if (value && typeof value === 'object') {
+      if (seen.has(value)) {
+        return '[Circular]';
+      }
+      seen.add(value);
+    }
+
+    return value;
+  };
+};
+
+/**
+ * Converte qualquer valor para texto JSON seguro para colunas JSON do MySQL.
+ * - Objetos/arrays sao serializados com saneamento
+ * - Strings sao saneadas; se nao forem JSON valido, viram JSON string
+ *
+ * @param {*} value
+ * @returns {string|null}
+ */
+export const toSafeJsonColumnValue = (value) => {
+  if (value === undefined || value === null) {
+    return null;
+  }
+
+  if (typeof value === 'string') {
+    const sanitized = sanitizeUnicodeString(value);
+    try {
+      const parsed = JSON.parse(sanitized);
+      const normalizedJson = JSON.stringify(parsed, createSafeJsonReplacer());
+      return normalizedJson === undefined ? null : normalizedJson;
+    } catch {
+      return JSON.stringify(sanitized);
+    }
+  }
+
+  try {
+    const json = JSON.stringify(value, createSafeJsonReplacer());
+    return json === undefined ? null : json;
+  } catch {
+    return JSON.stringify('[Unserializable]');
+  }
+};

package/app/utils/json/jsonSanitizer.test.js

@@ -0,0 +1,40 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { sanitizeUnicodeString, toSafeJsonColumnValue } from './jsonSanitizer.js';
+
+test('sanitizeUnicodeString mantem pares surrogate validos', () => {
+  const input = 'emoji \uD83D\uDE00 ok';
+  assert.equal(sanitizeUnicodeString(input), input);
+});
+
+test('sanitizeUnicodeString substitui surrogates invalidos por U+FFFD', () => {
+  const input = `invalido \ud800 meio \udc00 fim`;
+  const output = sanitizeUnicodeString(input);
+  assert.equal(output, 'invalido \uFFFD meio \uFFFD fim');
+});
+
+test('toSafeJsonColumnValue sanitiza objeto com surrogate invalido', () => {
+  const raw = {
+    text: `abc\ud800def`,
+    nested: { note: `x\udc00y` },
+  };
+
+  const json = toSafeJsonColumnValue(raw);
+  assert.equal(typeof json, 'string');
+
+  const parsed = JSON.parse(json);
+  assert.equal(parsed.text, 'abc\uFFFDdef');
+  assert.equal(parsed.nested.note, 'x\uFFFDy');
+});
+
+test('toSafeJsonColumnValue sanitiza JSON string com escape de surrogate invalido', () => {
+  const raw = '{"text":"\\ud800"}';
+  const json = toSafeJsonColumnValue(raw);
+  const parsed = JSON.parse(json);
+  assert.equal(parsed.text, '\uFFFD');
+});
+
+test('toSafeJsonColumnValue transforma texto simples em JSON string valido', () => {
+  const json = toSafeJsonColumnValue('texto simples');
+  assert.equal(json, '"texto simples"');
+});

package/app/utils/logger/loggerModule.js

@@ -0,0 +1,262 @@
+import 'dotenv/config';
+
+import winston from 'winston';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import { cleanEnv, str } from 'envalid';
+
+import util from 'node:util';
+import fs from 'node:fs';
+
+import { fileURLToPath } from 'node:url';
+import path from 'node:path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const LOG_LEVELS = { error: 0, warn: 1, info: 2, http: 3, verbose: 4, debug: 5, silly: 6 };
+const LOG_LEVEL_NAMES = Object.keys(LOG_LEVELS);
+
+const env = cleanEnv(process.env, {
+  NODE_ENV: str({
+    choices: ['development', 'production', 'test'],
+    default: 'development',
+    desc: 'Node environment',
+  }),
+  LOG_LEVEL: str({
+    choices: LOG_LEVEL_NAMES,
+    default: process.env.NODE_ENV === 'production' ? 'info' : 'debug',
+    desc: 'Logging level',
+  }),
+  ECOSYSTEM_NAME: str({ default: 'system', desc: 'Service name for logs' }),
+  name: str({ default: undefined, desc: 'PM2 application name (standard)' }),
+  PM2_INSTANCE_ID: str({ default: undefined, desc: 'PM2 instance ID (standard)' }),
+  NODE_APP_INSTANCE: str({ default: undefined, desc: 'PM2 instance ID (alternative)' }),
+  pm_id: str({ default: undefined, desc: 'PM2 instance ID (legacy)' }),
+});
+
+const _IS_PRODUCTION = env.NODE_ENV === 'production';
+const DEFAULT_LOG_LEVEL = env.LOG_LEVEL;
+const INSTANCE_ID = env.PM2_INSTANCE_ID ?? env.NODE_APP_INSTANCE ?? env.pm_id ?? 'local';
+const ECOSYSTEM_NAME = env.name ?? env.ECOSYSTEM_NAME ?? 'system';
+const NODE_ENV = env.NODE_ENV;
+
+const PROJECT_ROOT = path.resolve(__dirname, '..', '..', '..');
+const LOG_DIR_PATH = path.join(PROJECT_ROOT, 'logs');
+
+const LOG_DEFAULTS = {
+  LOG_DIR: LOG_DIR_PATH,
+  APP_LOG_FILENAME: 'application-%DATE%.log',
+  ERROR_LOG_FILENAME: 'error-%DATE%.log',
+  WARN_LOG_FILENAME: 'warn-%DATE%.log',
+  DATE_PATTERN: 'YYYY-MM-DD',
+  ZIPPED_ARCHIVE: true,
+  MAX_SIZE_APP: '20m',
+  MAX_FILES_APP: '14d',
+  MAX_SIZE_ERROR: '10m',
+  MAX_FILES_ERROR: '30d',
+  MAX_SIZE_WARN: '10m',
+  MAX_FILES_WARN: '14d',
+  FILE_PERMISSIONS: 0o777,
+  DIR_PERMISSIONS: 0o777,
+};
+
+const LOG_COLORS = {
+  error: 'red',
+  warn: 'yellow',
+  info: 'green',
+  http: 'magenta',
+  verbose: 'cyan',
+  debug: 'blue',
+  silly: 'grey',
+};
+winston.addColors(LOG_COLORS);
+
+const consoleFormat = winston.format.combine(
+  winston.format.timestamp({ format: () => new Date().toISOString() }),
+  winston.format.colorize({ all: true }),
+  winston.format.splat(),
+  winston.format.metadata({
+    fillExcept: [
+      'message',
+      'level',
+      'timestamp',
+      'label',
+      'service',
+      'instanceId',
+      'environment',
+      'stack',
+    ],
+  }),
+  winston.format.printf((info) => {
+    const { timestamp, level, message, metadata, stack } = info;
+    const label = metadata?.label;
+    const labelPart = label ? ` [${label}]` : '';
+    const metaToPrint = { ...metadata };
+    if (label) {
+      delete metaToPrint.label;
+    }
+
+    const metaPart =
+      Object.keys(metaToPrint).length > 0
+        ? ` ${util.inspect(metaToPrint, { colors: true, depth: 2 })}`
+        : '';
+
+    const servicePart = info.service ? ` [${info.service}]` : '';
+    const instancePart = info.instanceId ? ` [${info.instanceId}]` : '';
+
+    const stackPart = stack ? `\n${stack}` : '';
+
+    return `[${timestamp}] [${level}]${servicePart}${instancePart}${labelPart} - ${message}${metaPart}${stackPart}`;
+  }),
+);
+
+const fileFormat = winston.format.combine(
+  winston.format.timestamp(),
+  winston.format.splat(),
+  winston.format.errors({ stack: true }),
+  winston.format.metadata({
+    fillExcept: ['message', 'level', 'timestamp', 'service', 'instanceId', 'environment', 'stack'],
+  }),
+  winston.format.json(),
+);
+
+const getDefaultTransportDefinitions = (level) => [
+  {
+    type: 'console',
+    options: {
+      level: level,
+      format: consoleFormat,
+      handleExceptions: true,
+      handleRejections: true,
+    },
+  },
+  {
+    type: 'dailyRotateFile',
+    options: {
+      filename: path.join(LOG_DEFAULTS.LOG_DIR, LOG_DEFAULTS.APP_LOG_FILENAME),
+      datePattern: LOG_DEFAULTS.DATE_PATTERN,
+      zippedArchive: LOG_DEFAULTS.ZIPPED_ARCHIVE,
+      maxSize: LOG_DEFAULTS.MAX_SIZE_APP,
+      maxFiles: LOG_DEFAULTS.MAX_FILES_APP,
+      level: level,
+      format: fileFormat,
+      mode: LOG_DEFAULTS.FILE_PERMISSIONS,
+    },
+  },
+  {
+    type: 'dailyRotateFile',
+    options: {
+      filename: path.join(LOG_DEFAULTS.LOG_DIR, LOG_DEFAULTS.ERROR_LOG_FILENAME),
+      level: 'error',
+      datePattern: LOG_DEFAULTS.DATE_PATTERN,
+      zippedArchive: LOG_DEFAULTS.ZIPPED_ARCHIVE,
+      maxSize: LOG_DEFAULTS.MAX_SIZE_ERROR,
+      maxFiles: LOG_DEFAULTS.MAX_FILES_ERROR,
+      format: fileFormat,
+      mode: LOG_DEFAULTS.FILE_PERMISSIONS,
+      handleExceptions: true,
+      handleRejections: true,
+    },
+  },
+  {
+    type: 'dailyRotateFile',
+    options: {
+      filename: path.join(LOG_DEFAULTS.LOG_DIR, LOG_DEFAULTS.WARN_LOG_FILENAME),
+      level: 'warn',
+      datePattern: LOG_DEFAULTS.DATE_PATTERN,
+      zippedArchive: LOG_DEFAULTS.ZIPPED_ARCHIVE,
+      maxSize: LOG_DEFAULTS.MAX_SIZE_WARN,
+      maxFiles: LOG_DEFAULTS.MAX_FILES_WARN,
+      format: fileFormat,
+      mode: LOG_DEFAULTS.FILE_PERMISSIONS,
+    },
+  },
+];
+
+function ensureLogDirectoryExists() {
+  const logDir = LOG_DEFAULTS.LOG_DIR;
+  const dirMode = LOG_DEFAULTS.DIR_PERMISSIONS;
+
+  try {
+    fs.mkdirSync(logDir, { recursive: true, mode: dirMode });
+
+    console.log(
+      `[ LoggerSetup ] Diretório de log garantido: '${logDir}' (modo ${dirMode.toString(8)})`,
+    );
+  } catch (error) {
+    throw new Error(
+      `Falha na configuração do Logger: Não foi possível acessar/criar o diretório de log '${logDir}'. Erro original: ${error.message}`,
+    );
+  }
+}
+
+const createLoggerInstance = (overrideOptions = {}) => {
+  ensureLogDirectoryExists();
+
+  const effectiveLevel = overrideOptions.level || DEFAULT_LOG_LEVEL;
+
+  let configuredTransports;
+  if (overrideOptions.transports) {
+    configuredTransports = overrideOptions.transports;
+  } else {
+    const transportDefinitions =
+      overrideOptions.transportDefinitions || getDefaultTransportDefinitions(effectiveLevel);
+    configuredTransports = transportDefinitions
+      .map((def) => {
+        try {
+          switch (def.type) {
+            case 'console':
+              return new winston.transports.Console(def.options);
+            case 'dailyRotateFile':
+              return new DailyRotateFile(def.options);
+            default:
+              console.warn(
+                `[ LoggerSetup ] Tipo de transporte desconhecido: ${def.type}. Pulando.`,
+              );
+              return null;
+          }
+        } catch (error) {
+          console.error(
+            `[ LoggerSetup ] Falha ao criar transporte tipo ${def.type}: ${error.message}`,
+            error,
+          );
+          return null;
+        }
+      })
+      .filter(Boolean);
+  }
+
+  const baseDefaultMeta = {
+    service: ECOSYSTEM_NAME,
+    instanceId: INSTANCE_ID,
+    environment: NODE_ENV,
+  };
+
+  const defaultMeta = { ...baseDefaultMeta, ...(overrideOptions.defaultMeta || {}) };
+
+  const loggerFormat =
+    overrideOptions.format || winston.format.combine(winston.format.errors({ stack: true }));
+
+  const loggerInstance = winston.createLogger({
+    level: effectiveLevel,
+    levels: LOG_LEVELS,
+    format: loggerFormat,
+    defaultMeta: defaultMeta,
+    transports: configuredTransports,
+    exitOnError: false,
+  });
+
+  loggerInstance.on('error', (error) => {
+    console.error('Erro ocorrido dentro do Winston Logger:', error);
+  });
+
+  console.log(
+    `[ LoggerSetup ] Instância do Logger criada. Nível: ${effectiveLevel}, Env: ${NODE_ENV}, Instância: ${INSTANCE_ID}, Serviço: ${ECOSYSTEM_NAME}`,
+  );
+
+  return loggerInstance;
+};
+
+const logger = createLoggerInstance();
+
+export default logger;

package/app/utils/systemMetrics/systemMetricsModule.js

@@ -0,0 +1,91 @@
+import os from 'node:os';
+import process from 'node:process';
+
+const formatBytes = (bytes) => {
+  if (bytes === 0) return '0 Bytes';
+  const k = 1024;
+  const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
+  const i = Math.floor(Math.log(bytes) / Math.log(k));
+  return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
+};
+
+const formatDuration = (totalSeconds) => {
+  const total = Math.max(0, Math.floor(totalSeconds));
+  const days = Math.floor(total / 86400);
+  const hours = Math.floor((total % 86400) / 3600);
+  const minutes = Math.floor((total % 3600) / 60);
+  const seconds = total % 60;
+
+  const time = [hours, minutes, seconds].map((value) => String(value).padStart(2, '0')).join(':');
+  return days > 0 ? `${days}d ${time}` : time;
+};
+
+export const getSystemMetrics = () => {
+  const totalMemory = os.totalmem();
+  const freeMemory = os.freemem();
+  const usedMemory = totalMemory - freeMemory;
+  const memoryUsagePercentage = (usedMemory / totalMemory) * 100;
+
+  const cpus = os.cpus();
+  const totalCpus = cpus.length;
+  let totalIdle = 0;
+  let totalTick = 0;
+
+  for (const cpu of cpus) {
+    for (const type in cpu.times) {
+      totalTick += cpu.times[type];
+    }
+    totalIdle += cpu.times.idle;
+  }
+
+  const cpuUsagePercentage = 100 - (totalIdle / totalTick) * 100;
+
+  const processUptimeSeconds = process.uptime();
+  const systemUptimeSeconds = os.uptime();
+  const uptime = formatDuration(processUptimeSeconds);
+  const systemUptime = formatDuration(systemUptimeSeconds);
+  const loadAverage = os.loadavg();
+  const cpuSpeedAverage =
+    totalCpus > 0
+      ? Math.round(cpus.reduce((sum, cpu) => sum + (cpu.speed || 0), 0) / totalCpus)
+      : 0;
+  const memoryUsage = process.memoryUsage();
+
+  return {
+    usoCpuPercentual: parseFloat(cpuUsagePercentage.toFixed(2)),
+    cargaMedia: loadAverage.map((value) => parseFloat(value.toFixed(2))),
+    totalCpus,
+    cpuModelo: cpus[0]?.model || 'Desconhecido',
+    cpuVelocidadeMediaMHz: cpuSpeedAverage,
+
+    usoMemoriaPercentual: parseFloat(memoryUsagePercentage.toFixed(2)),
+    memoriaTotal: formatBytes(totalMemory),
+    memoriaLivre: formatBytes(freeMemory),
+    memoriaUsada: formatBytes(usedMemory),
+    memoriaProcesso: {
+      rss: formatBytes(memoryUsage.rss),
+      heapTotal: formatBytes(memoryUsage.heapTotal),
+      heapUsado: formatBytes(memoryUsage.heapUsed),
+      external: formatBytes(memoryUsage.external),
+      arrayBuffers: formatBytes(memoryUsage.arrayBuffers || 0),
+    },
+
+    uptime,
+    uptimeSistema: systemUptime,
+    uptimeSegundos: Math.floor(processUptimeSeconds),
+    uptimeSistemaSegundos: Math.floor(systemUptimeSeconds),
+    plataforma: os.platform(),
+    arquitetura: os.arch(),
+    hostname: os.hostname(),
+    tipo: os.type(),
+    release: os.release(),
+    versaoNode: process.version,
+    nodeEnv: process.env.NODE_ENV || 'development',
+    pid: process.pid,
+    ppid: process.ppid,
+    cpus: cpus.map((cpu) => ({
+      modelo: cpu.model,
+      velocidade: cpu.speed,
+    })),
+  };
+};