games_app/backend/dist/repositories/analyticsRepository.js
2026-06-29 15:01:23 +02:00

742 lines
34 KiB
JavaScript

"use strict";
var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
var desc = Object.getOwnPropertyDescriptor(m, k);
if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
desc = { enumerable: true, get: function() { return m[k]; } };
}
Object.defineProperty(o, k2, desc);
}) : (function(o, m, k, k2) {
if (k2 === undefined) k2 = k;
o[k2] = m[k];
}));
var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
Object.defineProperty(o, "default", { enumerable: true, value: v });
}) : function(o, v) {
o["default"] = v;
});
var __importStar = (this && this.__importStar) || (function () {
var ownKeys = function(o) {
ownKeys = Object.getOwnPropertyNames || function (o) {
var ar = [];
for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
return ar;
};
return ownKeys(o);
};
return function (mod) {
if (mod && mod.__esModule) return mod;
var result = {};
if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
__setModuleDefault(result, mod);
return result;
};
})();
Object.defineProperty(exports, "__esModule", { value: true });
exports.getUserKpis = getUserKpis;
exports.getDepositKpis = getDepositKpis;
exports.getWithdrawalKpis = getWithdrawalKpis;
exports.getBonusKpis = getBonusKpis;
exports.getAdjustmentKpis = getAdjustmentKpis;
exports.getWalletBalances = getWalletBalances;
exports.getFinancialPerformance = getFinancialPerformance;
exports.getGameAnalytics = getGameAnalytics;
exports.getUserSecurityKpis = getUserSecurityKpis;
exports.getUserActivityKpis = getUserActivityKpis;
exports.getRecentLogins = getRecentLogins;
exports.getGeographyStats = getGeographyStats;
exports.getDemographics = getDemographics;
exports.getTimeSeries = getTimeSeries;
exports.getAlertsSummary = getAlertsSummary;
const connection_1 = require("../db/connection");
const mvCharts = __importStar(require("./analyticsMaterializedQueries"));
const analyticsCache_1 = require("../utils/analyticsCache");
const onlineUsersRepository_1 = require("./onlineUsersRepository");
async function useDashboardMv() {
return mvCharts.areDashboardMaterializedViewsReady();
}
function num(v) {
if (v == null)
return 0;
return typeof v === 'number' ? v : parseInt(String(v), 10) || 0;
}
/** User KPI aggregates. */
async function getUserKpis(range) {
if (await useDashboardMv()) {
const rows = await (0, connection_1.query)(`WITH period AS (
SELECT $1::timestamptz AS from_ts, $2::timestamptz AS to_ts
),
prev AS (
SELECT ($1::timestamptz - ($2::timestamptz - $1::timestamptz)) AS from_ts, $1::timestamptz AS to_ts
)
SELECT
(SELECT COUNT(*)::text FROM users) AS total_users,
(SELECT COUNT(*)::text FROM users u, period p WHERE u.created_at BETWEEN p.from_ts AND p.to_ts) AS new_users,
(SELECT COUNT(*)::text FROM users u
LEFT JOIN user_admin_stats s ON s.user_id = u.id
CROSS JOIN period p
WHERE COALESCE(s.last_activity_at, u.created_at) < p.from_ts) AS inactive_users,
(SELECT COUNT(*)::text FROM users u, prev WHERE u.created_at BETWEEN prev.from_ts AND prev.to_ts) AS prev_new_users,
(SELECT COUNT(*)::text FROM users u JOIN roles r ON r.id = u.role_id WHERE r.name IN ('admin', 'moderator')) AS admin_count`, [range.from, range.to]);
const activeUsers = await mvCharts.mvActiveUsersInPeriod(range);
const [onlineNow, onlineInApp] = await Promise.all([
(0, onlineUsersRepository_1.countConnectedOnGame)(),
(0, onlineUsersRepository_1.countConnectedInApp)(),
]);
const r = rows[0];
const newUsers = num(r?.new_users);
const prevNew = num(r?.prev_new_users);
const growthRate = prevNew > 0 ? ((newUsers - prevNew) / prevNew) * 100 : newUsers > 0 ? 100 : 0;
return {
totalUsers: num(r?.total_users),
newUsers,
activeUsers,
inactiveUsers: num(r?.inactive_users),
signupGrowthRate: Math.round(growthRate * 100) / 100,
onlineNow,
onlineInApp,
adminCount: num(r?.admin_count),
};
}
const rows = await (0, connection_1.query)(`WITH period AS (
SELECT $1::timestamptz AS from_ts, $2::timestamptz AS to_ts
),
prev AS (
SELECT ($1::timestamptz - ($2::timestamptz - $1::timestamptz)) AS from_ts, $1::timestamptz AS to_ts
)
SELECT
(SELECT COUNT(*)::text FROM users) AS total_users,
(SELECT COUNT(*)::text FROM users u, period p WHERE u.created_at BETWEEN p.from_ts AND p.to_ts) AS new_users,
(SELECT COUNT(DISTINCT x.user_id)::text FROM (
SELECT user_id FROM audit_logs, period p WHERE action = 'login' AND created_at BETWEEN p.from_ts AND p.to_ts
UNION
SELECT user_id FROM candle_predict_bets, period p WHERE created_at BETWEEN p.from_ts AND p.to_ts
) x) AS active_users,
(SELECT COUNT(*)::text FROM users u
LEFT JOIN user_admin_stats s ON s.user_id = u.id
CROSS JOIN period p
WHERE COALESCE(s.last_activity_at, u.created_at) < p.from_ts) AS inactive_users,
(SELECT COUNT(*)::text FROM users u, prev WHERE u.created_at BETWEEN prev.from_ts AND prev.to_ts) AS prev_new_users,
(SELECT COUNT(*)::text FROM users u JOIN roles r ON r.id = u.role_id WHERE r.name IN ('admin', 'moderator')) AS admin_count`, [range.from, range.to]);
const [onlineNow, onlineInApp] = await Promise.all([
(0, onlineUsersRepository_1.countConnectedOnGame)(),
(0, onlineUsersRepository_1.countConnectedInApp)(),
]);
const r = rows[0];
const newUsers = num(r?.new_users);
const prevNew = num(r?.prev_new_users);
const growthRate = prevNew > 0 ? ((newUsers - prevNew) / prevNew) * 100 : newUsers > 0 ? 100 : 0;
return {
totalUsers: num(r?.total_users),
newUsers,
activeUsers: num(r?.active_users),
inactiveUsers: num(r?.inactive_users),
signupGrowthRate: Math.round(growthRate * 100) / 100,
onlineNow,
onlineInApp,
adminCount: num(r?.admin_count),
};
}
/** Deposit aggregates for the selected period. */
async function getDepositKpis(range) {
if (await useDashboardMv()) {
return mvCharts.mvTransactionKpis(range, 'deposit');
}
const rows = await (0, connection_1.query)(`SELECT
COALESCE(SUM(amount), 0)::text AS total_amount,
COUNT(*)::text AS total_count,
COUNT(DISTINCT user_id)::text AS unique_users,
COALESCE(MAX(amount), 0)::text AS max_amount
FROM transactions
WHERE type = 'deposit' AND status = 'completed'
AND created_at BETWEEN $1 AND $2`, [range.from, range.to]);
const r = rows[0];
const totalAmount = num(r?.total_amount);
const uniqueUsers = num(r?.unique_users);
return {
totalAmountRaw: totalAmount,
totalCount: num(r?.total_count),
uniqueUsers,
averagePerUserRaw: uniqueUsers > 0 ? Math.round(totalAmount / uniqueUsers) : 0,
maxAmountRaw: num(r?.max_amount),
};
}
/** Withdrawal aggregates for the selected period. */
async function getWithdrawalKpis(range) {
if (await useDashboardMv()) {
return mvCharts.mvTransactionKpis(range, 'withdrawal');
}
const rows = await (0, connection_1.query)(`SELECT
COALESCE(SUM(amount), 0)::text AS total_amount,
COUNT(*)::text AS total_count,
COUNT(DISTINCT user_id)::text AS unique_users,
COALESCE(MAX(amount), 0)::text AS max_amount
FROM transactions
WHERE type = 'withdrawal' AND status = 'completed'
AND created_at BETWEEN $1 AND $2`, [range.from, range.to]);
const r = rows[0];
const totalAmount = num(r?.total_amount);
const uniqueUsers = num(r?.unique_users);
return {
totalAmountRaw: totalAmount,
totalCount: num(r?.total_count),
uniqueUsers,
averagePerUserRaw: uniqueUsers > 0 ? Math.round(totalAmount / uniqueUsers) : 0,
maxAmountRaw: num(r?.max_amount),
};
}
/** Bonus aggregates for the selected period. */
async function getBonusKpis(range) {
if (await useDashboardMv()) {
return mvCharts.mvBonusKpis(range);
}
const rows = await (0, connection_1.query)(`SELECT
(SELECT COALESCE(SUM(amount), 0)::text FROM ledger_adjustments
WHERE adjustment_type = 'bonus' AND created_at BETWEEN $1 AND $2) AS bonus_total,
(SELECT COUNT(DISTINCT user_id)::text FROM ledger_adjustments
WHERE adjustment_type = 'bonus' AND created_at BETWEEN $1 AND $2) AS bonus_users,
(SELECT COALESCE(SUM(commission_amount), 0)::text FROM referral_commission_payouts
WHERE status = 'paid' AND COALESCE(paid_at, created_at) BETWEEN $1 AND $2) AS referral_total,
(SELECT COALESCE(SUM(amount), 0)::text FROM ledger_adjustments
WHERE adjustment_type = 'bonus' AND created_at BETWEEN $1 AND $2) AS manual_bonus`, [range.from, range.to]);
const r = rows[0];
const bonusTotal = num(r?.bonus_total) + num(r?.referral_total);
const bonusUsers = num(r?.bonus_users);
return {
totalAmountRaw: bonusTotal,
uniqueUsers: bonusUsers,
averagePerUserRaw: bonusUsers > 0 ? Math.round(bonusTotal / bonusUsers) : 0,
byType: {
manualBonusRaw: num(r?.manual_bonus),
referralCommissionRaw: num(r?.referral_total),
},
};
}
async function getAdjustmentKpis(range) {
if (await useDashboardMv()) {
return mvCharts.mvAdjustmentKpis(range);
}
const rows = await (0, connection_1.query)(`SELECT
COALESCE(SUM(amount), 0)::text AS total_amount,
COUNT(DISTINCT user_id)::text AS unique_users,
COUNT(*)::text AS total_count
FROM ledger_adjustments
WHERE adjustment_type = 'admin_adjustment'
AND created_at BETWEEN $1 AND $2`, [range.from, range.to]);
const r = rows[0];
const totalAmount = num(r?.total_amount);
const uniqueUsers = num(r?.unique_users);
const totalCount = num(r?.total_count);
return {
uniqueUsers,
totalAmountRaw: totalAmount,
averageRaw: totalCount > 0 ? Math.round(totalAmount / totalCount) : 0,
};
}
/** Current wallet balances across all users. */
async function getWalletBalances() {
const rows = await (0, connection_1.query)(`SELECT
COALESCE(SUM(s.main_balance_raw), 0)::text AS main_raw,
COALESCE(SUM(s.bonus_balance_raw), 0)::text AS bonus_raw,
COALESCE((
SELECT SUM(la.available_balance) FROM ledger_accounts la
JOIN wallet_types wt ON wt.id = la.wallet_type_id
WHERE wt.code = 'USDT_TRC20' AND la.account_kind = 'test'
), 0)::text AS test_raw
FROM user_admin_stats s`);
const r = rows[0];
const main = num(r?.main_raw);
const bonus = num(r?.bonus_raw);
const test = num(r?.test_raw);
return {
mainWalletRaw: main,
bonusWalletRaw: bonus,
testWalletRaw: test,
totalRaw: main + bonus + test,
distribution: [
{ kind: 'main', amountRaw: main },
{ kind: 'bonus', amountRaw: bonus },
{ kind: 'test', amountRaw: test },
],
};
}
async function getGameHousePnl(range, scope = 'real') {
const accountFilter = scope === 'real'
? "AND stake_account_kind IN ('main', 'bonus')"
: "AND stake_account_kind = 'test'";
if (await useDashboardMv()) {
return mvCharts.mvGameHousePnl(range, scope);
}
const rows = await (0, connection_1.query)(`SELECT
COALESCE(SUM(stake_raw), 0)::text AS stake,
COALESCE(SUM(payout_raw), 0)::text AS payout
FROM candle_predict_bets
WHERE created_at BETWEEN $1 AND $2
AND status IN ('won', 'lost', 'refunded')
${accountFilter}`, [range.from, range.to]);
const stake = num(rows[0]?.stake);
const payout = num(rows[0]?.payout);
return { houseNetPnlRaw: stake - payout };
}
async function getFinancialPerformance(range) {
const [deposits, withdrawals, bonus, adjustments, gamePnlReal, gamePnlTest] = await Promise.all([
getDepositKpis(range),
getWithdrawalKpis(range),
getBonusKpis(range),
getAdjustmentKpis(range),
getGameHousePnl(range, 'real'),
getGameHousePnl(range, 'test'),
]);
const depositRaw = deposits.totalAmountRaw;
const withdrawalRaw = withdrawals.totalAmountRaw;
return {
platformNetPnlRaw: gamePnlReal.houseNetPnlRaw,
platformNetPnlTestRaw: gamePnlTest.houseNetPnlRaw,
bonusCostRaw: bonus.totalAmountRaw,
adjustmentCostRaw: adjustments.totalAmountRaw,
depositWithdrawalRatio: withdrawalRaw > 0 ? Math.round((depositRaw / withdrawalRaw) * 100) / 100 : depositRaw > 0 ? null : 0,
};
}
async function getBetSegmentStats(range, whereExtra) {
const needsDirectQuery = /prediction_mode/i.test(whereExtra) || /stake_account_kind/i.test(whereExtra);
if (await useDashboardMv() && !needsDirectQuery) {
const filters = parseBetSegmentFilters(whereExtra);
return mvCharts.mvBetSegmentStats(range, filters);
}
const rows = await (0, connection_1.query)(`SELECT
COUNT(DISTINCT user_id)::text AS users,
COUNT(*)::text AS predictions,
COALESCE(SUM(stake_raw), 0)::text AS stake,
COALESCE(SUM(payout_raw), 0)::text AS payout,
SUM(CASE WHEN status = 'won' THEN 1 ELSE 0 END)::text AS won,
SUM(CASE WHEN status IN ('won', 'lost') THEN 1 ELSE 0 END)::text AS settled
FROM candle_predict_bets
WHERE created_at BETWEEN $1 AND $2 ${whereExtra}`, [range.from, range.to]);
const r = rows[0];
const stake = num(r?.stake);
const payout = num(r?.payout);
const settled = num(r?.settled);
const won = num(r?.won);
return {
users: num(r?.users),
predictions: num(r?.predictions),
stakeRaw: stake,
netPnlRaw: payout - stake,
winRate: settled > 0 ? Math.round((won / settled) * 10000) / 100 : 0,
};
}
function parseBetSegmentFilters(whereExtra) {
const filters = {};
if (/is_auto\s*=\s*FALSE/i.test(whereExtra))
filters.isAuto = false;
if (/is_auto\s*=\s*TRUE/i.test(whereExtra))
filters.isAuto = true;
if (/stake_account_kind\s*=\s*'test'/i.test(whereExtra)) {
filters.stakeAccountKinds = ['test'];
}
else if (/stake_account_kind\s+IN\s*\(\s*'main'\s*,\s*'bonus'\s*\)/i.test(whereExtra)) {
filters.stakeAccountKinds = ['main', 'bonus'];
}
return filters;
}
async function dailyPredictionCounts(range, whereExtra) {
return dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COUNT(*)::text AS value
FROM candle_predict_bets WHERE created_at BETWEEN $1 AND $2 ${whereExtra}
GROUP BY 1 ORDER BY 1`, range);
}
function emptySegment() {
return { users: 0, predictions: 0, stakeRaw: 0, netPnlRaw: 0, winRate: 0 };
}
async function getGameAnalytics(range, gameKey) {
if (gameKey !== 'all' && gameKey !== 'candle-predict') {
return {
participation: {
uniqueParticipants: 0,
totalPredictions: 0,
avgPredictionsPerUser: 0,
totalStakeRaw: 0,
},
manual: emptySegment(),
auto: emptySegment(),
multiCandle: emptySegment(),
testWallet: { uniqueUsers: 0, totalStakeRaw: 0, netPnlRaw: 0 },
cross: {
realManual: emptySegment(),
realAuto: emptySegment(),
realMulti: emptySegment(),
testManual: emptySegment(),
testAuto: emptySegment(),
testMulti: emptySegment(),
},
};
}
const overall = await getBetSegmentStats(range, '');
const manual = await getBetSegmentStats(range, `AND is_auto = FALSE AND prediction_mode = 'single' AND stake_account_kind IN ('main', 'bonus')`);
const auto = await getBetSegmentStats(range, `AND is_auto = TRUE AND stake_account_kind IN ('main', 'bonus')`);
const multiCandle = await getBetSegmentStats(range, `AND prediction_mode = 'multi_candle' AND stake_account_kind IN ('main', 'bonus')`);
const test = await getBetSegmentStats(range, `AND stake_account_kind = 'test'`);
return {
participation: {
uniqueParticipants: overall.users,
totalPredictions: overall.predictions,
avgPredictionsPerUser: overall.users > 0 ? Math.round((overall.predictions / overall.users) * 100) / 100 : 0,
totalStakeRaw: overall.stakeRaw,
},
manual,
auto,
multiCandle,
testWallet: {
uniqueUsers: test.users,
totalStakeRaw: test.stakeRaw,
netPnlRaw: test.netPnlRaw,
},
cross: {
realManual: await getBetSegmentStats(range, `AND stake_account_kind IN ('main', 'bonus') AND is_auto = FALSE AND prediction_mode = 'single'`),
realAuto: await getBetSegmentStats(range, `AND stake_account_kind IN ('main', 'bonus') AND is_auto = TRUE`),
realMulti: await getBetSegmentStats(range, `AND stake_account_kind IN ('main', 'bonus') AND prediction_mode = 'multi_candle'`),
testManual: await getBetSegmentStats(range, `AND stake_account_kind = 'test' AND is_auto = FALSE AND prediction_mode = 'single'`),
testAuto: await getBetSegmentStats(range, `AND stake_account_kind = 'test' AND is_auto = TRUE`),
testMulti: await getBetSegmentStats(range, `AND stake_account_kind = 'test' AND prediction_mode = 'multi_candle'`),
},
};
}
async function getUserSecurityKpis() {
const cached = (0, analyticsCache_1.getCachedSecurityKpis)();
if (cached)
return cached;
const rows = await (0, connection_1.query)(`SELECT
SUM(CASE WHEN email_verified THEN 1 ELSE 0 END)::text AS email_verified,
SUM(CASE WHEN NOT email_verified THEN 1 ELSE 0 END)::text AS email_unverified,
SUM(CASE WHEN totp_enabled THEN 1 ELSE 0 END)::text AS totp_on,
SUM(CASE WHEN NOT totp_enabled THEN 1 ELSE 0 END)::text AS totp_off,
SUM(CASE WHEN security_suspended_at IS NOT NULL THEN 1 ELSE 0 END)::text AS suspended,
SUM(CASE WHEN NOT is_enabled THEN 1 ELSE 0 END)::text AS disabled,
SUM(CASE WHEN NOT is_account_non_expired THEN 1 ELSE 0 END)::text AS expired,
SUM(CASE WHEN NOT is_credentials_non_expired THEN 1 ELSE 0 END)::text AS creds_expired,
SUM(CASE WHEN under_surveillance THEN 1 ELSE 0 END)::text AS under_surveillance,
SUM(CASE WHEN withdrawals_suspended THEN 1 ELSE 0 END)::text AS withdrawals_blocked
FROM users`);
const r = rows[0];
const result = {
emailVerified: num(r?.email_verified),
emailUnverified: num(r?.email_unverified),
totpEnabled: num(r?.totp_on),
totpDisabled: num(r?.totp_off),
suspendedAccounts: num(r?.suspended),
disabledAccounts: num(r?.disabled),
expiredAccounts: num(r?.expired),
credentialsExpired: num(r?.creds_expired),
underSurveillance: num(r?.under_surveillance),
withdrawalsBlocked: num(r?.withdrawals_blocked),
};
(0, analyticsCache_1.setCachedSecurityKpis)(result);
return result;
}
async function getUserActivityKpis(range) {
const rows = await (0, connection_1.query)(`SELECT
(SELECT COUNT(DISTINCT user_id)::text FROM audit_logs
WHERE action = 'login' AND created_at >= date_trunc('day', NOW())) AS active_today,
(SELECT COUNT(DISTINCT user_id)::text FROM audit_logs
WHERE action = 'login' AND created_at >= date_trunc('week', NOW())) AS active_week,
(SELECT COUNT(DISTINCT user_id)::text FROM audit_logs
WHERE action = 'login' AND created_at >= date_trunc('month', NOW())) AS active_month,
(SELECT COUNT(*)::text FROM users u
LEFT JOIN user_admin_stats s ON s.user_id = u.id
WHERE COALESCE(s.last_activity_at, u.created_at) < $1) AS inactive_period`, [range.from]);
const r = rows[0];
return {
activeToday: num(r?.active_today),
activeThisWeek: num(r?.active_week),
activeThisMonth: num(r?.active_month),
inactiveInPeriod: num(r?.inactive_period),
};
}
async function getRecentLogins(limit = 10) {
const rows = await (0, connection_1.query)(`SELECT al.user_id, u.first_name, u.last_name, MAX(al.created_at) AS logged_at
FROM audit_logs al
JOIN users u ON u.id = al.user_id
WHERE al.action = 'login'
GROUP BY al.user_id, u.first_name, u.last_name
ORDER BY logged_at DESC
LIMIT $1`, [limit]);
return rows.map((r) => ({
userId: r.user_id,
name: [r.first_name, r.last_name].filter(Boolean).join(' ') || 'User',
loggedAt: r.logged_at.toISOString(),
}));
}
async function getGeographyStats(range) {
if (await useDashboardMv()) {
return mvCharts.mvGeographyStats(range);
}
const rows = await (0, connection_1.query)(`WITH dep AS (
SELECT user_id, SUM(amount)::bigint AS total
FROM transactions
WHERE type = 'deposit' AND status = 'completed' AND created_at BETWEEN $1 AND $2
GROUP BY user_id
),
wdr AS (
SELECT user_id, SUM(amount)::bigint AS total
FROM transactions
WHERE type = 'withdrawal' AND status = 'completed' AND created_at BETWEEN $1 AND $2
GROUP BY user_id
),
act AS (
SELECT DISTINCT user_id FROM audit_logs
WHERE action = 'login' AND created_at BETWEEN $1 AND $2
)
SELECT
COALESCE(u.country_of_residence, 'XX') AS country,
COUNT(DISTINCT u.id)::text AS users,
COALESCE(SUM(dep.total), 0)::text AS deposits_raw,
COALESCE(SUM(wdr.total), 0)::text AS withdrawals_raw,
COALESCE(SUM(s.net_pnl_raw), 0)::text AS net_pnl_raw,
COUNT(DISTINCT act.user_id)::text AS active_users
FROM users u
LEFT JOIN user_admin_stats s ON s.user_id = u.id
LEFT JOIN dep ON dep.user_id = u.id
LEFT JOIN wdr ON wdr.user_id = u.id
LEFT JOIN act ON act.user_id = u.id
GROUP BY COALESCE(u.country_of_residence, 'XX')
ORDER BY COUNT(DISTINCT u.id) DESC
LIMIT 50`, [range.from, range.to]);
return rows.map((r) => ({
country: r.country,
users: num(r.users),
depositsRaw: num(r.deposits_raw),
withdrawalsRaw: num(r.withdrawals_raw),
netPnlRaw: num(r.net_pnl_raw),
activeUsers: num(r.active_users),
}));
}
async function getDemographics(range) {
if (await useDashboardMv()) {
return mvCharts.mvDemographics(range);
}
const [byGender, byAge] = await Promise.all([
(0, connection_1.query)(`SELECT
COALESCE(u.gender, 'unknown') AS gender,
COUNT(DISTINCT u.id)::text AS users,
COALESCE(SUM(s.total_stake_raw), 0)::text AS stake_raw,
COALESCE(SUM(s.net_pnl_raw), 0)::text AS net_pnl_raw,
COALESCE(SUM(dep.total), 0)::text AS deposits_raw
FROM users u
LEFT JOIN user_admin_stats s ON s.user_id = u.id
LEFT JOIN LATERAL (
SELECT SUM(amount)::bigint AS total FROM transactions
WHERE user_id = u.id AND type = 'deposit' AND status = 'completed'
AND created_at BETWEEN $1 AND $2
) dep ON TRUE
GROUP BY COALESCE(u.gender, 'unknown')`, [range.from, range.to]),
(0, connection_1.query)(`SELECT
CASE
WHEN u.date_of_birth IS NULL THEN 'unknown'
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) < 18 THEN 'under_18'
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) BETWEEN 18 AND 24 THEN '18_24'
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) BETWEEN 25 AND 34 THEN '25_34'
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) BETWEEN 35 AND 44 THEN '35_44'
WHEN EXTRACT(YEAR FROM age(u.date_of_birth)) BETWEEN 45 AND 54 THEN '45_54'
ELSE '55_plus'
END AS age_bucket,
COUNT(DISTINCT u.id)::text AS users,
COALESCE(SUM(s.total_stake_raw), 0)::text AS stake_raw,
COALESCE(SUM(s.net_pnl_raw), 0)::text AS net_pnl_raw,
COALESCE(SUM(dep.total), 0)::text AS deposits_raw
FROM users u
LEFT JOIN user_admin_stats s ON s.user_id = u.id
LEFT JOIN LATERAL (
SELECT SUM(amount)::bigint AS total FROM transactions
WHERE user_id = u.id AND type = 'deposit' AND status = 'completed'
AND created_at BETWEEN $1 AND $2
) dep ON TRUE
GROUP BY 1
ORDER BY 1`, [range.from, range.to]),
]);
return {
byGender: byGender.map((r) => ({
gender: r.gender,
users: num(r.users),
stakeRaw: num(r.stake_raw),
netPnlRaw: num(r.net_pnl_raw),
depositsRaw: num(r.deposits_raw),
})),
byAge: byAge.map((r) => ({
ageBucket: r.age_bucket,
users: num(r.users),
stakeRaw: num(r.stake_raw),
netPnlRaw: num(r.net_pnl_raw),
depositsRaw: num(r.deposits_raw),
})),
};
}
async function dailySeries(sql, range) {
const rows = await (0, connection_1.query)(sql, [range.from, range.to]);
return rows.map((r) => ({ date: r.day, value: num(r.value) }));
}
async function getTimeSeries(range) {
const useMv = await mvCharts.areChartMaterializedViewsReady();
const [signups, activeUsers, verifiedUsers, totpEnabled, deposits, withdrawals, bonuses, adjustments, netPnl, predictionsManual, predictionsAuto, predictionsMultiCandle, shortLong, stakesByInterval,] = await Promise.all([
dailySeries(`SELECT to_char(d, 'YYYY-MM-DD') AS day, COALESCE(COUNT(u.id), 0)::text AS value
FROM generate_series(date_trunc('day', $1::timestamptz), date_trunc('day', $2::timestamptz), '1 day') d
LEFT JOIN users u ON date_trunc('day', u.created_at) = d
GROUP BY d ORDER BY d`, range),
dailySeries(`SELECT to_char(d, 'YYYY-MM-DD') AS day, COUNT(DISTINCT al.user_id)::text AS value
FROM generate_series(date_trunc('day', $1::timestamptz), date_trunc('day', $2::timestamptz), '1 day') d
LEFT JOIN audit_logs al ON date_trunc('day', al.created_at) = d AND al.action = 'login'
GROUP BY d ORDER BY d`, range),
dailySeries(`SELECT to_char(d, 'YYYY-MM-DD') AS day, COUNT(u.id)::text AS value
FROM generate_series(date_trunc('day', $1::timestamptz), date_trunc('day', $2::timestamptz), '1 day') d
LEFT JOIN users u ON date_trunc('day', u.created_at) = d AND u.email_verified = TRUE
GROUP BY d ORDER BY d`, range),
dailySeries(`SELECT to_char(d, 'YYYY-MM-DD') AS day, COUNT(u.id)::text AS value
FROM generate_series(date_trunc('day', $1::timestamptz), date_trunc('day', $2::timestamptz), '1 day') d
LEFT JOIN users u ON date_trunc('day', u.updated_at) = d AND u.totp_enabled = TRUE
GROUP BY d ORDER BY d`, range),
useMv
? mvCharts.mvDailyDepositAmounts(range)
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COALESCE(SUM(amount), 0)::text AS value
FROM transactions WHERE type = 'deposit' AND status = 'completed' AND created_at BETWEEN $1 AND $2
GROUP BY 1 ORDER BY 1`, range),
useMv
? mvCharts.mvDailyWithdrawalAmounts(range)
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COALESCE(SUM(amount), 0)::text AS value
FROM transactions WHERE type = 'withdrawal' AND status = 'completed' AND created_at BETWEEN $1 AND $2
GROUP BY 1 ORDER BY 1`, range),
useMv
? mvCharts.mvDailyBonusAmountsWithReferrals(range)
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COALESCE(SUM(amount), 0)::text AS value
FROM ledger_adjustments WHERE adjustment_type = 'bonus' AND created_at BETWEEN $1 AND $2
GROUP BY 1 ORDER BY 1`, range),
useMv
? mvCharts.mvDailyAdjustmentAmounts(range)
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day, COALESCE(SUM(amount), 0)::text AS value
FROM ledger_adjustments WHERE adjustment_type = 'admin_adjustment' AND created_at BETWEEN $1 AND $2
GROUP BY 1 ORDER BY 1`, range),
useMv
? mvCharts.mvDailyNetPnl(range, 'real')
: dailySeries(`SELECT to_char(date_trunc('day', created_at), 'YYYY-MM-DD') AS day,
(COALESCE(SUM(stake_raw), 0) - COALESCE(SUM(payout_raw), 0))::text AS value
FROM candle_predict_bets
WHERE created_at BETWEEN $1 AND $2
AND status IN ('won','lost','refunded')
AND stake_account_kind IN ('main', 'bonus')
GROUP BY 1 ORDER BY 1`, range),
dailyPredictionCounts(range, `AND is_auto = FALSE AND prediction_mode = 'single'`),
useMv
? mvCharts.mvDailyPredictionCounts(range, true)
: dailyPredictionCounts(range, `AND is_auto = TRUE`),
dailyPredictionCounts(range, `AND prediction_mode = 'multi_candle'`),
useMv
? mvCharts.mvShortVsLong(range).then((rows) => rows.map((r) => ({
direction: r.direction,
count: String(r.count),
stake: String(r.stakeRaw),
})))
: (0, connection_1.query)(`SELECT direction, COUNT(*)::text AS count, COALESCE(SUM(stake_raw), 0)::text AS stake
FROM candle_predict_bets WHERE created_at BETWEEN $1 AND $2 GROUP BY direction`, [range.from, range.to]),
(0, connection_1.query)(`SELECT interval_minutes::text,
COUNT(DISTINCT user_id)::text AS participants,
COALESCE(SUM(stake_raw), 0)::text AS stake,
(COALESCE(SUM(stake_raw), 0) - COALESCE(SUM(payout_raw), 0))::text AS house_pnl
FROM candle_predict_bets WHERE created_at BETWEEN $1 AND $2
GROUP BY interval_minutes ORDER BY interval_minutes`, [range.from, range.to]),
]);
const loginHours = await (0, connection_1.query)(`SELECT EXTRACT(HOUR FROM created_at)::int::text AS hour, COUNT(*)::text AS count
FROM audit_logs WHERE action = 'login' AND created_at BETWEEN $1 AND $2
GROUP BY 1 ORDER BY 1`, [range.from, range.to]);
const betHoursPoints = useMv
? await mvCharts.mvBetHours(range)
: (await (0, connection_1.query)(`SELECT EXTRACT(HOUR FROM created_at)::int::text AS hour, COUNT(*)::text AS count
FROM candle_predict_bets WHERE created_at BETWEEN $1 AND $2
GROUP BY 1 ORDER BY 1`, [range.from, range.to])).map((r) => ({ hour: num(r.hour), count: num(r.count) }));
const periodUsers = await (0, connection_1.query)(`SELECT
(SELECT COUNT(*)::text FROM users WHERE created_at BETWEEN $1 AND $2) AS new_users,
(SELECT COUNT(DISTINCT al.user_id)::text FROM audit_logs al
JOIN users u ON u.id = al.user_id
WHERE al.action = 'login' AND al.created_at BETWEEN $1 AND $2 AND u.created_at < $1) AS returning`, [range.from, range.to]);
return {
signups,
activeUsers,
verifiedUsers,
totpEnabled,
deposits,
withdrawals,
bonuses,
adjustments,
netPnl,
predictionsManual,
predictionsAuto,
predictionsMultiCandle,
shortVsLong: shortLong.map((r) => ({
direction: r.direction,
count: num(r.count),
stakeRaw: num(r.stake),
})),
byInterval: stakesByInterval.map((r) => ({
intervalMinutes: num(r.interval_minutes),
participants: num(r.participants),
stakeRaw: num(r.stake),
housePnlRaw: num(r.house_pnl),
})),
loginHours: loginHours.map((r) => ({ hour: num(r.hour), count: num(r.count) })),
betHours: betHoursPoints,
retention: {
newUsers: num(periodUsers[0]?.new_users),
returningUsers: num(periodUsers[0]?.returning),
},
};
}
async function getAlertsSummary(range) {
const [openAlerts, recentAlerts, failedLogins] = await Promise.all([
(0, connection_1.query)(`SELECT COUNT(*)::text AS count FROM security_alerts WHERE status = 'open'`),
(0, connection_1.query)(`SELECT id, alert_type, severity, status, created_at, user_id
FROM security_alerts
WHERE created_at BETWEEN $1 AND $2
ORDER BY created_at DESC LIMIT 20`, [range.from, range.to]),
(0, connection_1.query)(`SELECT COUNT(*)::text AS count FROM security_alerts
WHERE alert_type ILIKE '%login%' AND created_at BETWEEN $1 AND $2`, [range.from, range.to]),
]);
const depositSpike = await detectSpike('deposit', range);
const withdrawalSpike = await detectSpike('withdrawal', range);
return {
openAlertsCount: num(openAlerts[0]?.count),
failedLoginAlerts: num(failedLogins[0]?.count),
depositSpike,
withdrawalSpike,
recentAlerts: recentAlerts.map((a) => ({
id: a.id,
type: a.alert_type,
severity: a.severity,
status: a.status,
userId: a.user_id,
createdAt: a.created_at.toISOString(),
})),
};
}
async function detectSpike(txType, range) {
const { currentRaw, previousRaw } = (await useDashboardMv())
? await mvCharts.mvTransactionSpike(txType, range)
: await (async () => {
const durationMs = range.to.getTime() - range.from.getTime();
const prevFrom = new Date(range.from.getTime() - durationMs);
const rows = await (0, connection_1.query)(`SELECT 'current' AS period, COALESCE(SUM(amount), 0)::text AS v
FROM transactions
WHERE type = $5 AND status = 'completed' AND created_at BETWEEN $1 AND $2
UNION ALL
SELECT 'previous', COALESCE(SUM(amount), 0)::text
FROM transactions
WHERE type = $5 AND status = 'completed' AND created_at BETWEEN $3 AND $4`, [range.from, range.to, prevFrom, range.from, txType]);
return {
currentRaw: num(rows.find((r) => r.period === 'current')?.v),
previousRaw: num(rows.find((r) => r.period === 'previous')?.v),
};
})();
const spikePercent = previousRaw > 0 ? Math.round(((currentRaw - previousRaw) / previousRaw) * 10000) / 100 : currentRaw > 0 ? 100 : 0;
return {
currentRaw,
previousRaw,
spikePercent,
isUnusual: Math.abs(spikePercent) >= 50 && currentRaw > previousRaw,
};
}
//# sourceMappingURL=analyticsRepository.js.map