2026-10-23 19:56:38 -07:00
|
|
|
const jwt = require("jsonwebtoken");
|
2026-10-23 11:43:49 -05:00
|
|
|
|
2026-11-17 20:05:00 +06:00
|
|
|
const IDEMPOTENCY_TTL_MS = 5 * 60 * 1000; // 5 minutes
|
|
|
|
|
const IDEMPOTENCY_MAX_ENTRIES = 20000;
|
|
|
|
|
const CLEANUP_INTERVAL_MS = 60 * 1000;
|
|
|
|
|
|
2026-10-23 11:43:49 -05:00
|
|
|
function setupSocketHandlers(io, bufferQueue, worker, options = {}) {
|
2026-11-17 20:05:00 +06:00
|
|
|
const getRuntimeConfig =
|
|
|
|
|
typeof options.getRuntimeConfig === "function"
|
|
|
|
|
? options.getRuntimeConfig
|
|
|
|
|
: () => ({
|
|
|
|
|
jwtSecret:
|
|
|
|
|
options.jwtSecret ||
|
2026-11-18 05:18:55 +06:00
|
|
|
(process.env.DATASTACK_JWT_SECRET || "").trim() ||
|
|
|
|
|
(process.env.NODE_ENV === "production"
|
|
|
|
|
? ""
|
|
|
|
|
: "datastack-jwt-default-secret-key-32-chars-long"),
|
2026-11-17 20:05:00 +06:00
|
|
|
maxEventsPerSec: 100,
|
|
|
|
|
maxPayloadSizeBytes: 100 * 1024,
|
|
|
|
|
batchFlushThreshold: 500,
|
|
|
|
|
enableIdempotency: true,
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
const verifyClientInDb =
|
|
|
|
|
typeof options.verifyClientInDb === "function"
|
|
|
|
|
? options.verifyClientInDb
|
|
|
|
|
: async () => ({ allowed: true });
|
|
|
|
|
|
|
|
|
|
const recordClientActivity =
|
|
|
|
|
typeof options.recordClientActivity === "function"
|
|
|
|
|
? options.recordClientActivity
|
|
|
|
|
: () => undefined;
|
|
|
|
|
|
|
|
|
|
const onBufferPush =
|
|
|
|
|
typeof options.onBufferPush === "function"
|
|
|
|
|
? options.onBufferPush
|
|
|
|
|
: () => undefined;
|
|
|
|
|
|
2026-10-23 11:43:49 -05:00
|
|
|
const idempotencyMap = new Map();
|
|
|
|
|
const rateLimitMap = new Map();
|
2026-11-17 20:05:00 +06:00
|
|
|
let lastCleanupAt = Date.now();
|
|
|
|
|
|
2026-11-18 05:18:55 +06:00
|
|
|
function cleanupMaps(now, force = false) {
|
2026-11-17 20:05:00 +06:00
|
|
|
if (
|
2026-11-18 05:18:55 +06:00
|
|
|
!force &&
|
2026-11-17 20:05:00 +06:00
|
|
|
now - lastCleanupAt < CLEANUP_INTERVAL_MS &&
|
|
|
|
|
idempotencyMap.size <= IDEMPOTENCY_MAX_ENTRIES
|
|
|
|
|
) {
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
lastCleanupAt = now;
|
|
|
|
|
|
|
|
|
|
for (const [key, timestamp] of idempotencyMap.entries()) {
|
|
|
|
|
if (now - timestamp > IDEMPOTENCY_TTL_MS) {
|
|
|
|
|
idempotencyMap.delete(key);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
for (const [clientId, rl] of rateLimitMap.entries()) {
|
|
|
|
|
if (now - rl.start > 10000) {
|
|
|
|
|
rateLimitMap.delete(clientId);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-18 05:18:55 +06:00
|
|
|
function getSecurityStats() {
|
|
|
|
|
cleanupMaps(Date.now(), true);
|
|
|
|
|
const config = getRuntimeConfig();
|
|
|
|
|
return {
|
|
|
|
|
activeIdempotencyKeys: idempotencyMap.size,
|
|
|
|
|
rateLimitedClientsCount: rateLimitMap.size,
|
|
|
|
|
maxPayloadSizeBytes: Number(config.maxPayloadSizeBytes) || 100 * 1024,
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-17 20:05:00 +06:00
|
|
|
function validateSingleEvent(clientId, eventId, rawData, clientRateLimit) {
|
|
|
|
|
const config = getRuntimeConfig();
|
|
|
|
|
const now = Date.now();
|
|
|
|
|
cleanupMaps(now);
|
|
|
|
|
|
2026-11-18 03:20:00 +06:00
|
|
|
// 1. Idempotency check (read-only check first; record only after rate-limit & payload checks pass)
|
|
|
|
|
const idempotencyKey = `${clientId}:${eventId}`;
|
2026-11-17 20:05:00 +06:00
|
|
|
if (config.enableIdempotency && eventId) {
|
2026-11-18 03:20:00 +06:00
|
|
|
const existingTime = idempotencyMap.get(idempotencyKey);
|
2026-11-17 20:05:00 +06:00
|
|
|
if (existingTime && now - existingTime < IDEMPOTENCY_TTL_MS) {
|
|
|
|
|
return {
|
|
|
|
|
allowed: false,
|
|
|
|
|
duplicate: true,
|
2026-11-18 02:51:04 +06:00
|
|
|
code: "DUPLICATE_EVENT",
|
2026-11-17 20:05:00 +06:00
|
|
|
reason: "Duplicate event dropped",
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-18 03:20:00 +06:00
|
|
|
// 2. Payload byte size check (before consuming rate-limit quota)
|
|
|
|
|
const payloadStr =
|
|
|
|
|
typeof rawData === "string" ? rawData : JSON.stringify(rawData ?? {});
|
|
|
|
|
const byteLength = Buffer.byteLength(payloadStr, "utf8");
|
|
|
|
|
const maxBytes = Number(config.maxPayloadSizeBytes) || 100 * 1024;
|
|
|
|
|
if (byteLength > maxBytes) {
|
|
|
|
|
return {
|
|
|
|
|
allowed: false,
|
|
|
|
|
duplicate: false,
|
|
|
|
|
code: "PAYLOAD_TOO_LARGE",
|
|
|
|
|
reason: `PAYLOAD_TOO_LARGE: Payload (${(byteLength / 1024).toFixed(1)} KB) exceeds limit of ${(maxBytes / 1024).toFixed(0)} KB`,
|
|
|
|
|
};
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// 3. Rate limit check
|
2026-11-17 20:05:00 +06:00
|
|
|
const effectiveLimit = Math.min(
|
|
|
|
|
Number(clientRateLimit) || 100,
|
|
|
|
|
Number(config.maxEventsPerSec) || 100,
|
|
|
|
|
);
|
|
|
|
|
const rl = rateLimitMap.get(clientId);
|
|
|
|
|
if (!rl || now - rl.start >= 1000) {
|
|
|
|
|
rateLimitMap.set(clientId, { count: 1, start: now });
|
|
|
|
|
} else if (rl.count >= effectiveLimit) {
|
|
|
|
|
return {
|
|
|
|
|
allowed: false,
|
|
|
|
|
duplicate: false,
|
2026-11-18 02:51:04 +06:00
|
|
|
code: "RATE_LIMIT_EXCEEDED",
|
2026-11-17 20:05:00 +06:00
|
|
|
reason: `RATE_LIMIT_EXCEEDED: Limit of ${effectiveLimit} events/sec exceeded`,
|
|
|
|
|
};
|
|
|
|
|
} else {
|
|
|
|
|
rl.count += 1;
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-18 03:20:00 +06:00
|
|
|
// 4. Record idempotency key ONLY after event passes all checks
|
|
|
|
|
if (config.enableIdempotency && eventId) {
|
|
|
|
|
idempotencyMap.set(idempotencyKey, now);
|
2026-11-17 20:05:00 +06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return { allowed: true, payloadStr };
|
|
|
|
|
}
|
2026-10-23 11:43:49 -05:00
|
|
|
|
|
|
|
|
// Middleware: Handshake Auth
|
2026-11-17 20:05:00 +06:00
|
|
|
io.use(async (socket, next) => {
|
2026-10-23 11:43:49 -05:00
|
|
|
const authHeader =
|
|
|
|
|
socket.handshake.auth?.token ||
|
|
|
|
|
socket.handshake.headers?.authorization ||
|
|
|
|
|
socket.handshake.query?.token;
|
|
|
|
|
|
|
|
|
|
if (!authHeader) {
|
2026-10-23 19:56:38 -07:00
|
|
|
return next(new Error("AUTH_REQUIRED: Handshake missing JWT"));
|
2026-10-23 11:43:49 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
try {
|
2026-11-17 20:05:00 +06:00
|
|
|
const cleanToken = String(authHeader).startsWith("Bearer ")
|
|
|
|
|
? String(authHeader).slice(7).trim()
|
|
|
|
|
: String(authHeader).trim();
|
|
|
|
|
const config = getRuntimeConfig();
|
2026-11-18 05:18:55 +06:00
|
|
|
const minSecretLen = process.env.NODE_ENV === "production" ? 32 : 1;
|
|
|
|
|
if (!config.jwtSecret || config.jwtSecret.length < minSecretLen) {
|
|
|
|
|
return next(
|
|
|
|
|
new Error("AUTH_UNAVAILABLE: DATASTACK_JWT_SECRET is not configured"),
|
|
|
|
|
);
|
|
|
|
|
}
|
2026-11-17 20:05:00 +06:00
|
|
|
const decoded = jwt.verify(cleanToken, config.jwtSecret);
|
|
|
|
|
|
2026-11-18 05:18:55 +06:00
|
|
|
const normalizedClientId = String(decoded.clientId || "")
|
|
|
|
|
.trim()
|
|
|
|
|
.toLowerCase();
|
2026-11-17 20:05:00 +06:00
|
|
|
const dbCheck = await verifyClientInDb(
|
2026-11-18 05:18:55 +06:00
|
|
|
normalizedClientId,
|
2026-11-17 20:05:00 +06:00
|
|
|
cleanToken,
|
|
|
|
|
true,
|
|
|
|
|
);
|
|
|
|
|
if (!dbCheck.allowed) {
|
|
|
|
|
return next(new Error(dbCheck.reason || "CLIENT_REVOKED"));
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-18 05:18:55 +06:00
|
|
|
socket.data.clientId = normalizedClientId;
|
2026-11-17 20:05:00 +06:00
|
|
|
socket.data.token = cleanToken;
|
|
|
|
|
socket.data.rateLimit =
|
|
|
|
|
dbCheck.rateLimit || decoded.rateLimit || config.maxEventsPerSec || 100;
|
2026-10-23 11:43:49 -05:00
|
|
|
next();
|
|
|
|
|
} catch (err) {
|
|
|
|
|
next(new Error(`AUTH_INVALID: ${err.message}`));
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
2026-11-18 05:18:55 +06:00
|
|
|
const ENVELOPE_KEYS = new Set(["eventId", "timestamp", "data", "clientId"]);
|
|
|
|
|
function extractBatchItemData(safeItem) {
|
|
|
|
|
if (
|
|
|
|
|
safeItem &&
|
|
|
|
|
typeof safeItem === "object" &&
|
|
|
|
|
!Array.isArray(safeItem) &&
|
|
|
|
|
safeItem.data !== undefined
|
|
|
|
|
) {
|
|
|
|
|
const keys = Object.keys(safeItem);
|
|
|
|
|
if (keys.every((k) => ENVELOPE_KEYS.has(k))) {
|
|
|
|
|
return safeItem.data;
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
return safeItem;
|
|
|
|
|
}
|
|
|
|
|
|
2026-10-23 19:56:38 -07:00
|
|
|
io.on("connection", (socket) => {
|
2026-10-23 11:43:49 -05:00
|
|
|
const clientId = socket.data.clientId;
|
|
|
|
|
socket.join(`client:${clientId}`);
|
|
|
|
|
|
|
|
|
|
// Single event
|
2026-11-17 20:05:00 +06:00
|
|
|
socket.on("sync_data", async (payload, callback) => {
|
2026-10-23 11:43:49 -05:00
|
|
|
try {
|
2026-11-17 20:05:00 +06:00
|
|
|
const dbCheck = await verifyClientInDb(
|
|
|
|
|
clientId,
|
|
|
|
|
socket.data.token,
|
|
|
|
|
false,
|
|
|
|
|
);
|
|
|
|
|
if (!dbCheck.allowed) {
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback({
|
|
|
|
|
success: false,
|
2026-11-18 02:51:04 +06:00
|
|
|
code: "CLIENT_REVOKED",
|
2026-11-17 20:05:00 +06:00
|
|
|
error: dbCheck.reason || "CLIENT_REVOKED",
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
socket.disconnect(true);
|
2026-10-23 11:43:49 -05:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-17 20:05:00 +06:00
|
|
|
const effectiveClientRate =
|
|
|
|
|
dbCheck.rateLimit || socket.data.rateLimit || 100;
|
|
|
|
|
const safePayload = payload && typeof payload === "object" ? payload : {};
|
|
|
|
|
const eventId =
|
|
|
|
|
safePayload.eventId ||
|
|
|
|
|
`evt_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
|
|
|
|
|
const timestamp = safePayload.timestamp || new Date().toISOString();
|
|
|
|
|
|
|
|
|
|
const check = validateSingleEvent(
|
|
|
|
|
clientId,
|
|
|
|
|
eventId,
|
|
|
|
|
safePayload.data,
|
|
|
|
|
effectiveClientRate,
|
|
|
|
|
);
|
|
|
|
|
if (!check.allowed) {
|
|
|
|
|
if (check.duplicate) {
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback({ success: true, eventId, note: "DUPLICATE_DROPPED" });
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
if (callback) {
|
2026-11-18 02:51:04 +06:00
|
|
|
callback({
|
|
|
|
|
success: false,
|
|
|
|
|
eventId,
|
|
|
|
|
code: check.code,
|
|
|
|
|
error: check.reason,
|
|
|
|
|
});
|
2026-11-17 20:05:00 +06:00
|
|
|
}
|
2026-10-23 11:43:49 -05:00
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
const event = {
|
|
|
|
|
clientId,
|
|
|
|
|
eventId,
|
|
|
|
|
timestamp,
|
2026-11-17 20:05:00 +06:00
|
|
|
payload: check.payloadStr,
|
2026-10-23 11:43:49 -05:00
|
|
|
};
|
|
|
|
|
|
|
|
|
|
bufferQueue.push(event);
|
2026-11-17 20:05:00 +06:00
|
|
|
recordClientActivity(clientId, 1);
|
|
|
|
|
onBufferPush();
|
2026-10-23 11:43:49 -05:00
|
|
|
|
|
|
|
|
if (callback) callback({ success: true, eventId });
|
|
|
|
|
} catch (err) {
|
|
|
|
|
if (callback) callback({ success: false, error: err.message });
|
|
|
|
|
}
|
|
|
|
|
});
|
|
|
|
|
|
|
|
|
|
// Batch event
|
2026-11-17 20:05:00 +06:00
|
|
|
socket.on("batch_sync", async (batch, callback) => {
|
|
|
|
|
try {
|
|
|
|
|
if (!Array.isArray(batch)) {
|
|
|
|
|
if (callback) callback({ success: false, error: "Expected array" });
|
|
|
|
|
return;
|
|
|
|
|
}
|
2026-10-23 11:43:49 -05:00
|
|
|
|
2026-11-17 20:05:00 +06:00
|
|
|
const dbCheck = await verifyClientInDb(
|
2026-10-23 11:43:49 -05:00
|
|
|
clientId,
|
2026-11-17 20:05:00 +06:00
|
|
|
socket.data.token,
|
|
|
|
|
false,
|
|
|
|
|
);
|
|
|
|
|
if (!dbCheck.allowed) {
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback({
|
|
|
|
|
success: false,
|
|
|
|
|
processed: 0,
|
|
|
|
|
rejected: batch.length,
|
2026-11-18 02:51:04 +06:00
|
|
|
code: "CLIENT_REVOKED",
|
2026-11-17 20:05:00 +06:00
|
|
|
error: dbCheck.reason || "CLIENT_REVOKED",
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
socket.disconnect(true);
|
|
|
|
|
return;
|
|
|
|
|
}
|
2026-10-23 11:43:49 -05:00
|
|
|
|
2026-11-17 20:05:00 +06:00
|
|
|
const effectiveClientRate =
|
|
|
|
|
dbCheck.rateLimit || socket.data.rateLimit || 100;
|
|
|
|
|
let processed = 0;
|
|
|
|
|
let rejected = 0;
|
2026-11-18 02:51:04 +06:00
|
|
|
let duplicates = 0;
|
|
|
|
|
let hitRateLimit = false;
|
|
|
|
|
let hitPayloadLimit = false;
|
|
|
|
|
const rateLimitedEventIds = [];
|
|
|
|
|
const oversizedEventIds = [];
|
2026-11-17 20:05:00 +06:00
|
|
|
const errors = [];
|
|
|
|
|
|
|
|
|
|
for (const item of batch) {
|
|
|
|
|
const safeItem = item && typeof item === "object" ? item : {};
|
|
|
|
|
const eventId =
|
|
|
|
|
safeItem.eventId ||
|
|
|
|
|
`evt_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
|
|
|
|
|
const timestamp = safeItem.timestamp || new Date().toISOString();
|
2026-11-18 05:18:55 +06:00
|
|
|
const rawData = extractBatchItemData(safeItem);
|
2026-11-17 20:05:00 +06:00
|
|
|
|
|
|
|
|
const check = validateSingleEvent(
|
|
|
|
|
clientId,
|
|
|
|
|
eventId,
|
|
|
|
|
rawData,
|
|
|
|
|
effectiveClientRate,
|
|
|
|
|
);
|
|
|
|
|
if (!check.allowed) {
|
2026-11-18 02:51:04 +06:00
|
|
|
if (check.duplicate) {
|
|
|
|
|
duplicates += 1;
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
rejected += 1;
|
|
|
|
|
if (check.code === "RATE_LIMIT_EXCEEDED") {
|
|
|
|
|
hitRateLimit = true;
|
|
|
|
|
rateLimitedEventIds.push(eventId);
|
|
|
|
|
}
|
|
|
|
|
if (check.code === "PAYLOAD_TOO_LARGE") {
|
|
|
|
|
hitPayloadLimit = true;
|
|
|
|
|
oversizedEventIds.push(eventId);
|
|
|
|
|
}
|
|
|
|
|
if (errors.length < 5) {
|
|
|
|
|
errors.push(`${eventId}: ${check.reason}`);
|
2026-11-17 20:05:00 +06:00
|
|
|
}
|
|
|
|
|
continue;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bufferQueue.push({
|
|
|
|
|
clientId,
|
|
|
|
|
eventId,
|
|
|
|
|
timestamp,
|
|
|
|
|
payload: check.payloadStr,
|
|
|
|
|
});
|
|
|
|
|
processed += 1;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (processed > 0) {
|
|
|
|
|
recordClientActivity(clientId, processed);
|
|
|
|
|
onBufferPush();
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-18 02:51:04 +06:00
|
|
|
if (processed === 0 && duplicates === 0 && rejected > 0) {
|
|
|
|
|
const code = hitPayloadLimit
|
|
|
|
|
? "PAYLOAD_TOO_LARGE"
|
|
|
|
|
: hitRateLimit
|
|
|
|
|
? "RATE_LIMIT_EXCEEDED"
|
|
|
|
|
: "BATCH_REJECTED";
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback({
|
|
|
|
|
success: false,
|
|
|
|
|
processed,
|
|
|
|
|
rejected,
|
|
|
|
|
duplicates,
|
|
|
|
|
code,
|
|
|
|
|
error: errors[0] || "Batch validation failed",
|
|
|
|
|
errors,
|
|
|
|
|
...(rateLimitedEventIds.length > 0 ? { rateLimitedEventIds } : {}),
|
|
|
|
|
...(oversizedEventIds.length > 0 ? { oversizedEventIds } : {}),
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2026-11-17 20:05:00 +06:00
|
|
|
if (callback) {
|
|
|
|
|
callback({
|
|
|
|
|
success: true,
|
|
|
|
|
processed,
|
|
|
|
|
rejected,
|
2026-11-18 02:51:04 +06:00
|
|
|
duplicates,
|
|
|
|
|
...(rateLimitedEventIds.length > 0 ? { rateLimitedEventIds } : {}),
|
|
|
|
|
...(oversizedEventIds.length > 0 ? { oversizedEventIds } : {}),
|
2026-11-17 20:05:00 +06:00
|
|
|
...(errors.length > 0 ? { errors } : {}),
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
} catch (err) {
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback({
|
|
|
|
|
success: false,
|
|
|
|
|
processed: 0,
|
|
|
|
|
rejected: Array.isArray(batch) ? batch.length : 0,
|
|
|
|
|
error: err.message,
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
}
|
2026-10-23 11:43:49 -05:00
|
|
|
});
|
2026-11-18 02:23:01 +06:00
|
|
|
|
|
|
|
|
// Heartbeat & Reconnection Verification Event
|
|
|
|
|
socket.on("ping_verify", async (_payload, callback) => {
|
|
|
|
|
try {
|
|
|
|
|
const dbCheck = await verifyClientInDb(
|
|
|
|
|
clientId,
|
|
|
|
|
socket.data.token,
|
|
|
|
|
true,
|
|
|
|
|
);
|
|
|
|
|
if (!dbCheck.allowed) {
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback({
|
|
|
|
|
success: false,
|
|
|
|
|
status: "REVOKED",
|
|
|
|
|
error: dbCheck.reason || "CLIENT_REVOKED",
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
socket.disconnect(true);
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
const config = getRuntimeConfig();
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback({
|
|
|
|
|
success: true,
|
|
|
|
|
status: "VERIFIED",
|
|
|
|
|
clientId,
|
|
|
|
|
rateLimit: dbCheck.rateLimit || socket.data.rateLimit || 100,
|
|
|
|
|
maxPayloadSizeBytes: config.maxPayloadSizeBytes,
|
|
|
|
|
serverTime: new Date().toISOString(),
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
} catch (err) {
|
|
|
|
|
if (callback) {
|
|
|
|
|
callback({
|
|
|
|
|
success: false,
|
|
|
|
|
status: "ERROR",
|
|
|
|
|
error: err.message,
|
|
|
|
|
});
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
});
|
2026-10-23 11:43:49 -05:00
|
|
|
});
|
2026-11-18 05:18:55 +06:00
|
|
|
|
|
|
|
|
return {
|
|
|
|
|
getSecurityStats,
|
|
|
|
|
};
|
2026-10-23 11:43:49 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
module.exports = { setupSocketHandlers };
|