express-sequelize-traffic 0.1.0 → 0.2.0

package/src/services/analyticsService.js

@@ -1,286 +0,0 @@
-import { Op, fn, col, literal } from "sequelize";
-
-function toNumber(value, decimals = 2) {
-  const parsed = Number(value ?? 0);
-
-  if (!Number.isFinite(parsed)) {
-    return 0;
-  }
-
-  return Number(parsed.toFixed(decimals));
-}
-
-function normalizeLog(log) {
-  return {
-    id: log.id,
-    userId: log.userId,
-    sessionId: log.sessionId,
-    method: log.method,
-    route: log.route,
-    originalUrl: log.originalUrl,
-    statusCode: Number(log.statusCode),
-    durationMs: Number(log.durationMs),
-    isSlow: Boolean(log.isSlow),
-    ip: log.ip,
-    userAgent: log.userAgent,
-    startedAt: log.startedAt,
-    endedAt: log.endedAt,
-    createdAt: log.createdAt,
-    updatedAt: log.updatedAt,
-  };
-}
-
-function buildTimeline(logs = []) {
-  const buckets = new Map();
-
-  for (const log of logs) {
-    const bucketDate = new Date(log.createdAt);
-
-    bucketDate.setMinutes(0, 0, 0);
-
-    const bucketKey = bucketDate.toISOString();
-
-    buckets.set(bucketKey, (buckets.get(bucketKey) || 0) + 1);
-  }
-
-  return [...buckets.entries()]
-    .sort(([left], [right]) => left.localeCompare(right))
-    .slice(-24)
-    .map(([timestamp, totalRequests]) => ({
-      timestamp,
-      totalRequests,
-    }));
-}
-
-function buildGroupKey(row) {
-  return `${row.route}::${row.method}`;
-}
-
-function mapGroupedCounts(rows = []) {
-  const counts = new Map();
-
-  for (const row of rows) {
-    counts.set(buildGroupKey(row), Number(row.totalCount || 0));
-  }
-
-  return counts;
-}
-
-export function createAnalyticsService(TrafficLog) {
-  return {
-    async getOverview() {
-      const [
-        totalRequests,
-        averageDurationMsRaw,
-        slowRequestCount,
-        errorRequestCount,
-        uniqueUsers,
-        topRoutesRows,
-        slowestRoutesRows,
-        statusCodeRows,
-        latestRequests,
-        timelineLogs,
-      ] = await Promise.all([
-        TrafficLog.count(),
-        TrafficLog.aggregate("durationMs", "avg"),
-        TrafficLog.count({ where: { isSlow: true } }),
-        TrafficLog.count({
-          where: {
-            statusCode: { [Op.gte]: 400 },
-          },
-        }),
-        TrafficLog.count({
-          distinct: true,
-          col: "userId",
-          where: {
-            userId: { [Op.not]: null },
-          },
-        }),
-        TrafficLog.findAll({
-          attributes: [
-            "route",
-            [fn("COUNT", col("id")), "totalRequests"],
-          ],
-          where: {
-            route: { [Op.not]: null },
-          },
-          group: ["route"],
-          order: [[literal("totalRequests"), "DESC"]],
-          limit: 5,
-          raw: true,
-        }),
-        TrafficLog.findAll({
-          attributes: [
-            "route",
-            "method",
-            [fn("AVG", col("durationMs")), "averageDurationMs"],
-            [fn("MAX", col("durationMs")), "maxDurationMs"],
-            [fn("COUNT", col("id")), "totalRequests"],
-          ],
-          where: {
-            route: { [Op.not]: null },
-          },
-          group: ["route", "method"],
-          order: [[literal("averageDurationMs"), "DESC"]],
-          limit: 5,
-          raw: true,
-        }),
-        TrafficLog.findAll({
-          attributes: [
-            "statusCode",
-            [fn("COUNT", col("id")), "totalRequests"],
-          ],
-          group: ["statusCode"],
-          order: [["statusCode", "ASC"]],
-          raw: true,
-        }),
-        TrafficLog.findAll({
-          order: [["createdAt", "DESC"]],
-          limit: 10,
-          raw: true,
-        }),
-        TrafficLog.findAll({
-          attributes: ["createdAt"],
-          order: [["createdAt", "DESC"]],
-          limit: 1000,
-          raw: true,
-        }),
-      ]);
-
-      return {
-        totalRequests,
-        averageDurationMs: toNumber(averageDurationMsRaw),
-        slowRequestCount,
-        errorRequestCount,
-        uniqueUsers,
-        topRoutes: topRoutesRows.map((row) => ({
-          route: row.route,
-          totalRequests: Number(row.totalRequests),
-        })),
-        slowestRoutes: slowestRoutesRows.map((row) => ({
-          route: row.route,
-          method: row.method,
-          totalRequests: Number(row.totalRequests),
-          averageDurationMs: toNumber(row.averageDurationMs),
-          maxDurationMs: Number(row.maxDurationMs),
-        })),
-        statusCodeSummary: statusCodeRows.map((row) => ({
-          statusCode: Number(row.statusCode),
-          totalRequests: Number(row.totalRequests),
-        })),
-        latestRequests: latestRequests.map(normalizeLog),
-        requestsTimeline: buildTimeline(timelineLogs),
-      };
-    },
-
-    async getLive() {
-      const logs = await TrafficLog.findAll({
-        order: [["createdAt", "DESC"]],
-        limit: 100,
-        raw: true,
-      });
-
-      return logs.map(normalizeLog);
-    },
-
-    async getRoutes() {
-      const [baseRows, errorRows, slowRows] = await Promise.all([
-        TrafficLog.findAll({
-          attributes: [
-            "route",
-            "method",
-            [fn("COUNT", col("id")), "totalRequests"],
-            [fn("AVG", col("durationMs")), "averageDurationMs"],
-            [fn("MAX", col("durationMs")), "maxDurationMs"],
-          ],
-          where: {
-            route: { [Op.not]: null },
-          },
-          group: ["route", "method"],
-          order: [[literal("averageDurationMs"), "DESC"]],
-          raw: true,
-        }),
-        TrafficLog.findAll({
-          attributes: [
-            "route",
-            "method",
-            [fn("COUNT", col("id")), "totalCount"],
-          ],
-          where: {
-            route: { [Op.not]: null },
-            statusCode: { [Op.gte]: 400 },
-          },
-          group: ["route", "method"],
-          raw: true,
-        }),
-        TrafficLog.findAll({
-          attributes: [
-            "route",
-            "method",
-            [fn("COUNT", col("id")), "totalCount"],
-          ],
-          where: {
-            route: { [Op.not]: null },
-            isSlow: true,
-          },
-          group: ["route", "method"],
-          raw: true,
-        }),
-      ]);
-
-      const errorCounts = mapGroupedCounts(errorRows);
-      const slowCounts = mapGroupedCounts(slowRows);
-
-      return baseRows.map((row) => {
-        const key = buildGroupKey(row);
-
-        return {
-          route: row.route,
-          method: row.method,
-          totalRequests: Number(row.totalRequests),
-          averageDurationMs: toNumber(row.averageDurationMs),
-          maxDurationMs: Number(row.maxDurationMs),
-          errorCount: errorCounts.get(key) || 0,
-          slowCount: slowCounts.get(key) || 0,
-        };
-      });
-    },
-
-    async getUsers() {
-      const rows = await TrafficLog.findAll({
-        attributes: [
-          "userId",
-          [fn("COUNT", col("id")), "totalRequests"],
-          [fn("MAX", col("createdAt")), "lastSeenAt"],
-          [fn("AVG", col("durationMs")), "averageDurationMs"],
-        ],
-        where: {
-          userId: { [Op.not]: null },
-        },
-        group: ["userId"],
-        order: [[literal("totalRequests"), "DESC"]],
-        raw: true,
-      });
-
-      return rows.map((row) => ({
-        userId: row.userId,
-        totalRequests: Number(row.totalRequests),
-        lastSeenAt: row.lastSeenAt,
-        averageDurationMs: toNumber(row.averageDurationMs),
-      }));
-    },
-
-    async getErrors() {
-      const rows = await TrafficLog.findAll({
-        where: {
-          statusCode: { [Op.gte]: 400 },
-        },
-        order: [["createdAt", "DESC"]],
-        limit: 100,
-        raw: true,
-      });
-
-      return rows.map(normalizeLog);
-    },
-  };
-}

package/src/utils/dashboardAuth.js

@@ -1,71 +0,0 @@
-function parseBasicAuthHeader(headerValue) {
-  if (!headerValue || !headerValue.startsWith("Basic ")) {
-    return null;
-  }
-
-  try {
-    const decoded = Buffer.from(headerValue.slice(6), "base64").toString(
-      "utf8",
-    );
-    const separatorIndex = decoded.indexOf(":");
-
-    if (separatorIndex === -1) {
-      return null;
-    }
-
-    return {
-      username: decoded.slice(0, separatorIndex),
-      password: decoded.slice(separatorIndex + 1),
-    };
-  } catch (_error) {
-    return null;
-  }
-}
-
-export function isDashboardAuthEnabled(dashboard = {}) {
-  return Boolean(dashboard.enabled && dashboard.username && dashboard.password);
-}
-
-export function createBasicAuthMiddleware(dashboard = {}) {
-  if (!isDashboardAuthEnabled(dashboard)) {
-    return (_req, _res, next) => next();
-  }
-
-  return (req, res, next) => {
-    const credentials = parseBasicAuthHeader(req.headers.authorization);
-
-    if (
-      credentials?.username === dashboard.username &&
-      credentials?.password === dashboard.password
-    ) {
-      next();
-      return;
-    }
-
-    res.setHeader("WWW-Authenticate", 'Basic realm="Traffic Dashboard"');
-    res.status(401).json({ error: "Dashboard authentication required." });
-  };
-}
-
-export function createSocketAuthMiddleware(dashboard = {}) {
-  return (socket, next) => {
-    if (!isDashboardAuthEnabled(dashboard)) {
-      next();
-      return;
-    }
-
-    const credentials = parseBasicAuthHeader(
-      socket.handshake.headers.authorization,
-    );
-
-    if (
-      credentials?.username === dashboard.username &&
-      credentials?.password === dashboard.password
-    ) {
-      next();
-      return;
-    }
-
-    next(new Error("Dashboard authentication required."));
-  };
-}

package/src/utils/routeMatcher.js

@@ -1,53 +0,0 @@
-function normalizeRouteCandidate(route) {
-  if (Array.isArray(route)) {
-    return route[0] || "/";
-  }
-
-  if (route instanceof RegExp) {
-    return route.toString();
-  }
-
-  return route || null;
-}
-
-export function resolveTrackedRoute(req) {
-  const routePath = normalizeRouteCandidate(req.route?.path);
-
-  if (req.baseUrl && routePath) {
-    return routePath === "/" ? req.baseUrl || "/" : `${req.baseUrl}${routePath}`;
-  }
-
-  return routePath || req.path || req.originalUrl || "/";
-}
-
-function matchesIgnoredRoute(matcher, candidate) {
-  if (!candidate) {
-    return false;
-  }
-
-  if (matcher instanceof RegExp) {
-    return matcher.test(candidate);
-  }
-
-  if (typeof matcher === "function") {
-    return Boolean(matcher(candidate));
-  }
-
-  if (typeof matcher === "string") {
-    return candidate === matcher || candidate.startsWith(`${matcher}?`);
-  }
-
-  return false;
-}
-
-export function shouldIgnoreRoute({
-  route,
-  originalUrl,
-  ignoredRoutes = [],
-}) {
-  return ignoredRoutes.some(
-    (matcher) =>
-      matchesIgnoredRoute(matcher, route) ||
-      matchesIgnoredRoute(matcher, originalUrl),
-  );
-}

package/src/utils/safeAsync.js

@@ -1,13 +0,0 @@
-export async function safeAsync(task, options = {}) {
-  const { fallback = null, onError } = options;
-
-  try {
-    return await task();
-  } catch (error) {
-    if (typeof onError === "function") {
-      onError(error);
-    }
-
-    return fallback;
-  }
-}