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

685 lines
33 KiB
JavaScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.getSettings = getSettings;
exports.updateSettings = updateSettings;
exports.listLevels = listLevels;
exports.getLevelByNumber = getLevelByNumber;
exports.upsertLevel = upsertLevel;
exports.deleteLevel = deleteLevel;
exports.findUserByReferralCode = findUserByReferralCode;
exports.generateUniqueReferralCode = generateUniqueReferralCode;
exports.recordCommissionPayout = recordCommissionPayout;
exports.findCommissionPayoutById = findCommissionPayoutById;
exports.listPendingCommissionsDue = listPendingCommissionsDue;
exports.listReviewQueue = listReviewQueue;
exports.markCommissionPaid = markCommissionPaid;
exports.moveCommissionToReview = moveCommissionToReview;
exports.rejectCommissionPayout = rejectCommissionPayout;
exports.recordCommissionReviewDecision = recordCommissionReviewDecision;
exports.countReferredUserRealPredictions = countReferredUserRealPredictions;
exports.beneficiaryHasCompletedDeposit = beneficiaryHasCompletedDeposit;
exports.getReferralChain = getReferralChain;
exports.countDirectReferrals = countDirectReferrals;
exports.getMainAccountPredictionNetProfit = getMainAccountPredictionNetProfit;
exports.getWithdrawalGainsAlreadyCommissioned = getWithdrawalGainsAlreadyCommissioned;
exports.getReferrerProfile = getReferrerProfile;
exports.getReferralDownline = getReferralDownline;
exports.getBeneficiaryCommissionSummary = getBeneficiaryCommissionSummary;
exports.listBeneficiaryCommissions = listBeneficiaryCommissions;
exports.formatUserDisplayName = formatUserDisplayName;
exports.getAdminStats = getAdminStats;
exports.getBeneficiaryMonthlyCommissionStats = getBeneficiaryMonthlyCommissionStats;
exports.markCommissionClawedBack = markCommissionClawedBack;
exports.recordCommissionClawback = recordCommissionClawback;
exports.listRecentClawbacks = listRecentClawbacks;
exports.listClawbacksForExport = listClawbacksForExport;
exports.getFraudDashboardData = getFraudDashboardData;
const crypto_1 = require("crypto");
const connection_1 = require("../db/connection");
const PAYOUT_COLUMNS = `
id, beneficiary_user_id, referred_user_id, level_number, commission_source,
first_deposit_transaction_id, withdrawal_transaction_id, deposit_amount::text, commission_percent::text,
commission_amount::text, wallet_type_id, status, eligible_at, paid_at,
rejection_reason, sybil_score, sybil_signals, reviewed_by, reviewed_at,
review_note, created_at, updated_at
`;
function mapPayoutRow(row) {
const signals = row.sybil_signals;
return {
...row,
sybil_signals: Array.isArray(signals) ? signals : [],
};
}
async function getSettings() {
const rows = await (0, connection_1.query)(`SELECT id, enabled, default_referrer_user_id, bonus_withdrawable,
referrer_must_be_verified, referrer_must_have_deposited,
referred_must_be_verified, commission_hold_days, min_referred_predictions,
commission_max_pending_days, sybil_detection_enabled, sybil_review_threshold,
sybil_block_threshold, max_referrals_per_day,
max_commission_amount_per_referrer_month_raw::text,
max_commissions_per_referrer_month, slack_alerts_enabled,
deposit_commissions_enabled, withdrawal_commissions_enabled,
min_first_deposit_raw::text, commission_wallet_type_id, updated_at
FROM referral_program_settings WHERE id = 1`);
return rows[0];
}
async function updateSettings(input) {
const updates = [];
const values = [];
let i = 1;
const fieldMap = [
['enabled', 'enabled'],
['defaultReferrerUserId', 'default_referrer_user_id'],
['bonusWithdrawable', 'bonus_withdrawable'],
['referrerMustBeVerified', 'referrer_must_be_verified'],
['referrerMustHaveDeposited', 'referrer_must_have_deposited'],
['referredMustBeVerified', 'referred_must_be_verified'],
['commissionHoldDays', 'commission_hold_days'],
['minReferredPredictions', 'min_referred_predictions'],
['commissionMaxPendingDays', 'commission_max_pending_days'],
['sybilDetectionEnabled', 'sybil_detection_enabled'],
['sybilReviewThreshold', 'sybil_review_threshold'],
['sybilBlockThreshold', 'sybil_block_threshold'],
['maxReferralsPerDay', 'max_referrals_per_day'],
['maxCommissionAmountPerReferrerMonthRaw', 'max_commission_amount_per_referrer_month_raw'],
['maxCommissionsPerReferrerMonth', 'max_commissions_per_referrer_month'],
['slackAlertsEnabled', 'slack_alerts_enabled'],
['depositCommissionsEnabled', 'deposit_commissions_enabled'],
['withdrawalCommissionsEnabled', 'withdrawal_commissions_enabled'],
['minFirstDepositRaw', 'min_first_deposit_raw'],
['commissionWalletTypeId', 'commission_wallet_type_id'],
];
for (const [inputKey, column] of fieldMap) {
const value = input[inputKey];
if (value !== undefined) {
updates.push(`${column} = $${i++}`);
values.push(value);
}
}
if (updates.length > 0) {
updates.push('updated_at = NOW()');
await (0, connection_1.query)(`UPDATE referral_program_settings SET ${updates.join(', ')} WHERE id = 1`, values);
}
return getSettings();
}
async function listLevels() {
return (0, connection_1.query)(`SELECT level_number, commission_percent::text, is_active,
monthly_max_amount_raw::text, monthly_max_count,
created_at, updated_at
FROM referral_levels ORDER BY level_number ASC`);
}
async function getLevelByNumber(levelNumber) {
const rows = await (0, connection_1.query)(`SELECT level_number, commission_percent::text, is_active,
monthly_max_amount_raw::text, monthly_max_count,
created_at, updated_at
FROM referral_levels WHERE level_number = $1`, [levelNumber]);
return rows[0] ?? null;
}
async function upsertLevel(levelNumber, commissionPercent, isActive = true, monthlyMaxAmountRaw = '0', monthlyMaxCount = 0) {
await (0, connection_1.query)(`INSERT INTO referral_levels (level_number, commission_percent, is_active, monthly_max_amount_raw, monthly_max_count)
VALUES ($1, $2, $3, $4, $5)
ON CONFLICT (level_number) DO UPDATE SET
commission_percent = EXCLUDED.commission_percent,
is_active = EXCLUDED.is_active,
monthly_max_amount_raw = EXCLUDED.monthly_max_amount_raw,
monthly_max_count = EXCLUDED.monthly_max_count,
updated_at = NOW()`, [levelNumber, commissionPercent, isActive, monthlyMaxAmountRaw, monthlyMaxCount]);
}
async function deleteLevel(levelNumber) {
await (0, connection_1.query)('DELETE FROM referral_levels WHERE level_number = $1', [levelNumber]);
}
async function findUserByReferralCode(code) {
const normalized = code.trim().toUpperCase();
const rows = await (0, connection_1.query)(`SELECT id, email_verified FROM users
WHERE UPPER(referral_code) = $1 AND is_enabled = TRUE`, [normalized]);
return rows[0] ?? null;
}
async function generateUniqueReferralCode() {
for (let attempt = 0; attempt < 20; attempt++) {
const code = (0, crypto_1.randomBytes)(5).toString('hex').toUpperCase().slice(0, 8);
const existing = await (0, connection_1.query)('SELECT id FROM users WHERE referral_code = $1', [code]);
if (!existing[0])
return code;
}
throw new Error('Failed to generate unique referral code');
}
async function recordCommissionPayout(input) {
const source = input.commissionSource ?? 'deposit';
const rows = await (0, connection_1.query)(`INSERT INTO referral_commission_payouts
(beneficiary_user_id, referred_user_id, level_number, commission_source,
first_deposit_transaction_id, withdrawal_transaction_id,
deposit_amount, commission_percent, commission_amount, wallet_type_id,
status, eligible_at, sybil_score, sybil_signals)
VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14)
ON CONFLICT DO NOTHING
RETURNING id`, [
input.beneficiaryUserId,
input.referredUserId,
input.levelNumber,
source,
input.firstDepositTransactionId ?? null,
input.withdrawalTransactionId ?? null,
input.baseAmount.toString(),
input.commissionPercent,
input.commissionAmount.toString(),
input.walletTypeId,
input.status,
input.eligibleAt,
input.sybilScore ?? 0,
JSON.stringify(input.sybilSignals ?? []),
]);
return rows[0]?.id ?? '';
}
async function findCommissionPayoutById(payoutId) {
const rows = await (0, connection_1.query)(`SELECT ${PAYOUT_COLUMNS} FROM referral_commission_payouts WHERE id = $1`, [payoutId]);
return rows[0] ? mapPayoutRow(rows[0]) : null;
}
async function listPendingCommissionsDue(limit) {
const rows = await (0, connection_1.query)(`SELECT ${PAYOUT_COLUMNS}
FROM referral_commission_payouts
WHERE status = 'pending' AND eligible_at <= NOW()
ORDER BY eligible_at ASC
LIMIT $1`, [limit]);
return rows.map(mapPayoutRow);
}
async function listReviewQueue(opts) {
const limit = Math.min(opts.limit ?? 50, 100);
const offset = Math.max(opts.offset ?? 0, 0);
const countRows = await (0, connection_1.query)(`SELECT COUNT(*)::text AS count FROM referral_commission_payouts WHERE status = 'review'`);
const rows = await (0, connection_1.query)(`SELECT ${PAYOUT_COLUMNS}
FROM referral_commission_payouts
WHERE status = 'review'
ORDER BY sybil_score DESC, created_at ASC
LIMIT $1 OFFSET $2`, [limit, offset]);
return { items: rows.map(mapPayoutRow), total: Number(countRows[0]?.count ?? 0) };
}
async function markCommissionPaid(payoutId, fromStatuses = ['pending', 'review']) {
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
SET status = 'paid', paid_at = NOW(), updated_at = NOW()
WHERE id = $1 AND status = ANY($2::varchar[])
RETURNING id`, [payoutId, fromStatuses]);
return Boolean(rows[0]);
}
async function moveCommissionToReview(payoutId, sybilScore, sybilSignals) {
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
SET status = 'review', sybil_score = $2, sybil_signals = $3, updated_at = NOW()
WHERE id = $1 AND status = 'pending'
RETURNING id`, [payoutId, sybilScore, JSON.stringify(sybilSignals)]);
return Boolean(rows[0]);
}
async function rejectCommissionPayout(payoutId, status, reason, fromStatuses = ['pending', 'review']) {
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
SET status = $2, rejection_reason = $3, updated_at = NOW()
WHERE id = $1 AND status = ANY($4::varchar[])
RETURNING id`, [payoutId, status, reason, fromStatuses]);
return Boolean(rows[0]);
}
async function recordCommissionReviewDecision(input) {
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
SET reviewed_by = $2, reviewed_at = NOW(), review_note = $3, updated_at = NOW()
WHERE id = $1 AND status = 'review'
RETURNING id`, [input.payoutId, input.reviewerId, input.note ?? null]);
return Boolean(rows[0]);
}
async function countReferredUserRealPredictions(userId) {
const rows = await (0, connection_1.query)(`SELECT COUNT(*)::text AS count
FROM candle_predict_bets
WHERE user_id = $1 AND stake_account_kind IN ('main', 'bonus')`, [userId]);
return Number(rows[0]?.count ?? 0);
}
async function beneficiaryHasCompletedDeposit(userId) {
const rows = await (0, connection_1.query)(`SELECT 1 AS n FROM transactions
WHERE user_id = $1 AND type = 'deposit' AND status = 'completed'
LIMIT 1`, [userId]);
return Boolean(rows[0]);
}
async function getReferralChain(userId, maxLevels) {
const chain = [];
let currentId = userId;
for (let level = 1; level <= maxLevels; level++) {
if (!currentId)
break;
const rows = await (0, connection_1.query)('SELECT referred_by_user_id FROM users WHERE id = $1', [currentId]);
const referrerId = rows[0]?.referred_by_user_id ?? null;
if (!referrerId)
break;
chain.push({ userId: referrerId, level });
currentId = referrerId;
}
return chain;
}
async function countDirectReferrals(userId) {
const rows = await (0, connection_1.query)('SELECT COUNT(*)::text AS count FROM users WHERE referred_by_user_id = $1', [userId]);
return Number(rows[0]?.count ?? 0);
}
async function getMainAccountPredictionNetProfit(userId) {
const rows = await (0, connection_1.query)(`SELECT COALESCE(SUM(
CASE
WHEN status = 'won' THEN GREATEST(COALESCE(payout_raw, 0) - stake_raw, 0)
WHEN status = 'lost' THEN -stake_raw
ELSE 0
END
), 0)::text AS net
FROM candle_predict_bets
WHERE user_id = $1 AND stake_account_kind = 'main'
AND status IN ('won', 'lost')`, [userId]);
return BigInt(rows[0]?.net ?? '0');
}
async function getWithdrawalGainsAlreadyCommissioned(referredUserId) {
const rows = await (0, connection_1.query)(`SELECT COALESCE(SUM(deposit_amount), 0)::text AS total
FROM referral_commission_payouts
WHERE referred_user_id = $1
AND commission_source = 'withdrawal'
AND status NOT IN ('rejected', 'expired')`, [referredUserId]);
return BigInt(rows[0]?.total ?? '0');
}
async function getReferrerProfile(userId) {
const rows = await (0, connection_1.query)(`SELECT r.id AS referrer_id, r.referral_code, r.first_name, r.last_name, r.created_at
FROM users u
JOIN users r ON r.id = u.referred_by_user_id
WHERE u.id = $1`, [userId]);
const row = rows[0];
if (!row)
return null;
return {
userId: row.referrer_id,
referralCode: row.referral_code,
firstName: row.first_name,
lastName: row.last_name,
createdAt: row.created_at,
};
}
async function getReferralDownline(rootUserId, maxDepth) {
return (0, connection_1.query)(`WITH RECURSIVE downline AS (
SELECT u.id AS user_id,
u.referred_by_user_id AS parent_user_id,
1 AS level_number,
u.referral_code,
u.first_name,
u.last_name,
u.created_at,
u.first_deposit_at,
u.email_verified,
u.country_of_residence
FROM users u
WHERE u.referred_by_user_id = $1
UNION ALL
SELECT u.id,
u.referred_by_user_id,
d.level_number + 1,
u.referral_code,
u.first_name,
u.last_name,
u.created_at,
u.first_deposit_at,
u.email_verified,
u.country_of_residence
FROM users u
INNER JOIN downline d ON u.referred_by_user_id = d.user_id
WHERE d.level_number < $2
)
SELECT d.user_id,
d.parent_user_id,
d.level_number,
d.referral_code,
d.first_name,
d.last_name,
d.created_at,
d.first_deposit_at,
d.email_verified,
d.country_of_residence,
(SELECT COUNT(*)::text FROM users c WHERE c.referred_by_user_id = d.user_id) AS direct_referrals_count,
(SELECT COUNT(*)::text FROM candle_predict_bets b
WHERE b.user_id = d.user_id AND b.stake_account_kind IN ('main', 'bonus')) AS real_predictions_count,
COALESCE((
SELECT SUM(p.commission_amount)::text
FROM referral_commission_payouts p
WHERE p.beneficiary_user_id = $1 AND p.referred_user_id = d.user_id
AND p.status NOT IN ('rejected', 'expired')
), '0') AS commissions_generated_raw,
COALESCE((
SELECT SUM(p.commission_amount)::text
FROM referral_commission_payouts p
WHERE p.beneficiary_user_id = $1 AND p.referred_user_id = d.user_id
AND p.status = 'paid'
), '0') AS commissions_paid_raw,
COALESCE((
SELECT SUM(p.commission_amount)::text
FROM referral_commission_payouts p
WHERE p.beneficiary_user_id = $1 AND p.referred_user_id = d.user_id
AND p.status IN ('pending', 'review')
), '0') AS commissions_pending_raw
FROM downline d
ORDER BY d.level_number ASC, d.created_at ASC`, [rootUserId, maxDepth]);
}
async function getBeneficiaryCommissionSummary(beneficiaryUserId) {
const summaryRows = await (0, connection_1.query)(`SELECT
COALESCE(SUM(commission_amount) FILTER (
WHERE status NOT IN ('rejected', 'expired')
), 0)::text AS total,
COALESCE(SUM(commission_amount) FILTER (WHERE status = 'paid'), 0)::text AS paid,
COALESCE(SUM(commission_amount) FILTER (WHERE status = 'pending'), 0)::text AS pending,
COALESCE(SUM(commission_amount) FILTER (WHERE status = 'review'), 0)::text AS review,
COUNT(*)::text AS payout_count
FROM referral_commission_payouts
WHERE beneficiary_user_id = $1`, [beneficiaryUserId]);
const networkRows = await (0, connection_1.query)(`WITH RECURSIVE downline AS (
SELECT id FROM users WHERE referred_by_user_id = $1
UNION ALL
SELECT u.id FROM users u
INNER JOIN downline d ON u.referred_by_user_id = d.id
)
SELECT COUNT(*)::text AS count FROM downline`, [beneficiaryUserId]);
const s = summaryRows[0];
return {
totalEarnedRaw: BigInt(s?.total ?? '0'),
paidRaw: BigInt(s?.paid ?? '0'),
pendingRaw: BigInt(s?.pending ?? '0'),
reviewRaw: BigInt(s?.review ?? '0'),
networkSize: Number(networkRows[0]?.count ?? 0),
payoutCount: Number(s?.payout_count ?? 0),
};
}
async function listBeneficiaryCommissions(beneficiaryUserId, opts) {
const limit = Math.min(opts?.limit ?? 50, 200);
const offset = opts?.offset ?? 0;
const countRows = await (0, connection_1.query)(`SELECT COUNT(*)::text AS count FROM referral_commission_payouts WHERE beneficiary_user_id = $1`, [beneficiaryUserId]);
const rows = await (0, connection_1.query)(`SELECT p.id, p.referred_user_id, u.first_name, u.last_name, p.level_number,
p.commission_source, p.deposit_amount::text, p.commission_amount::text,
p.commission_percent::text, p.status, p.eligible_at, p.paid_at, p.created_at
FROM referral_commission_payouts p
JOIN users u ON u.id = p.referred_user_id
WHERE p.beneficiary_user_id = $1
ORDER BY p.created_at DESC
LIMIT $2 OFFSET $3`, [beneficiaryUserId, limit, offset]);
return {
total: Number(countRows[0]?.count ?? 0),
items: rows.map((r) => ({
id: r.id,
referredUserId: r.referred_user_id,
referredDisplayName: formatUserDisplayName(r.first_name, r.last_name, r.referred_user_id),
levelNumber: r.level_number,
commissionSource: r.commission_source,
baseAmount: r.deposit_amount,
commissionAmount: r.commission_amount,
commissionPercent: r.commission_percent,
status: r.status,
eligibleAt: r.eligible_at,
paidAt: r.paid_at,
createdAt: r.created_at,
})),
};
}
function formatUserDisplayName(firstName, lastName, userId) {
if (firstName?.trim()) {
const initial = lastName?.trim() ? ` ${lastName.trim().charAt(0)}.` : '';
return `${firstName.trim()}${initial}`;
}
return `User ${userId.slice(0, 8)}`;
}
async function getAdminStats() {
const usersByCountry = await (0, connection_1.query)(`SELECT COALESCE(c.name,
CASE
WHEN u.country_of_residence IS NULL OR u.country_of_residence = 'XX' THEN 'Non renseigné'
ELSE u.country_of_residence
END) AS country,
COUNT(*)::text AS count
FROM users u
LEFT JOIN countries c ON c.code = u.country_of_residence
GROUP BY u.country_of_residence, c.name
ORDER BY COUNT(*) DESC`);
const usersByNationality = await (0, connection_1.query)(`SELECT COALESCE(c.name, u.nationality, 'Non renseigné') AS nationality,
COUNT(*)::text AS count
FROM users u
LEFT JOIN countries c ON c.code = u.nationality
WHERE u.nationality IS NOT NULL
GROUP BY u.nationality, c.name
ORDER BY COUNT(*) DESC`);
const referralSummaryRows = await (0, connection_1.query)(`SELECT
(SELECT COUNT(*) FROM users WHERE referred_by_user_id IS NOT NULL)::text AS total_referred,
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'paid'), 0)::text AS total_commissions,
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'paid')::text AS payout_count,
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'pending'), 0)::text AS pending_commissions,
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'pending')::text AS pending_count,
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'review'), 0)::text AS review_commissions,
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'review')::text AS review_count`);
const topReferrers = await (0, connection_1.query)(`SELECT u.id AS user_id, u.referral_code,
COUNT(DISTINCT r.id)::text AS direct_referrals,
COALESCE(SUM(p.commission_amount) FILTER (WHERE p.status = 'paid'), 0)::text AS total_earned
FROM users u
LEFT JOIN users r ON r.referred_by_user_id = u.id
LEFT JOIN referral_commission_payouts p ON p.beneficiary_user_id = u.id
WHERE u.referral_code IS NOT NULL
GROUP BY u.id, u.referral_code
ORDER BY COUNT(DISTINCT r.id) DESC, COALESCE(SUM(p.commission_amount) FILTER (WHERE p.status = 'paid'), 0) DESC
LIMIT 20`);
const summary = referralSummaryRows[0];
return {
usersByCountry: usersByCountry.map((r) => ({ country: r.country, count: Number(r.count) })),
usersByNationality: usersByNationality.map((r) => ({ nationality: r.nationality, count: Number(r.count) })),
referralSummary: {
totalReferred: Number(summary?.total_referred ?? 0),
totalCommissionsPaid: summary?.total_commissions ?? '0',
payoutCount: Number(summary?.payout_count ?? 0),
pendingCommissions: summary?.pending_commissions ?? '0',
pendingCount: Number(summary?.pending_count ?? 0),
reviewCommissions: summary?.review_commissions ?? '0',
reviewCount: Number(summary?.review_count ?? 0),
},
topReferrers: topReferrers.map((r) => ({
userId: r.user_id,
referralCode: r.referral_code,
directReferrals: Number(r.direct_referrals),
totalEarned: r.total_earned,
})),
};
}
const ACTIVE_COMMISSION_STATUSES = ['pending', 'review', 'paid'];
async function getBeneficiaryMonthlyCommissionStats(beneficiaryUserId, levelNumber) {
const levelFilter = levelNumber != null ? 'AND level_number = $3' : '';
const params = [beneficiaryUserId, ACTIVE_COMMISSION_STATUSES];
if (levelNumber != null)
params.push(levelNumber);
const rows = await (0, connection_1.query)(`SELECT
COALESCE(SUM(commission_amount) FILTER (
WHERE status = ANY($2::varchar[])
AND created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
), 0)::text AS reserved_amount,
COUNT(*) FILTER (
WHERE status = ANY($2::varchar[])
AND created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
)::text AS reserved_count,
COALESCE(SUM(commission_amount) FILTER (
WHERE status = 'paid'
AND COALESCE(paid_at, created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
), 0)::text AS paid_amount,
COUNT(*) FILTER (
WHERE status = 'paid'
AND COALESCE(paid_at, created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
)::text AS paid_count
FROM referral_commission_payouts
WHERE beneficiary_user_id = $1 ${levelFilter}`, params);
const row = rows[0];
return {
reservedAmount: BigInt(row?.reserved_amount ?? '0'),
reservedCount: Number(row?.reserved_count ?? 0),
paidAmount: BigInt(row?.paid_amount ?? '0'),
paidCount: Number(row?.paid_count ?? 0),
};
}
async function markCommissionClawedBack(payoutId) {
const rows = await (0, connection_1.query)(`UPDATE referral_commission_payouts
SET status = 'clawed_back', updated_at = NOW()
WHERE id = $1 AND status = 'paid'
RETURNING id`, [payoutId]);
return Boolean(rows[0]);
}
async function recordCommissionClawback(input) {
const rows = await (0, connection_1.query)(`INSERT INTO referral_commission_clawbacks
(payout_id, beneficiary_user_id, amount, reason, clawed_by)
VALUES ($1, $2, $3, $4, $5)
RETURNING id`, [
input.payoutId,
input.beneficiaryUserId,
input.amount.toString(),
input.reason,
input.clawedBy,
]);
return rows[0].id;
}
async function listRecentClawbacks(limit = 20) {
return (0, connection_1.query)(`SELECT id, payout_id, beneficiary_user_id, amount::text, reason, clawed_by, created_at
FROM referral_commission_clawbacks
ORDER BY created_at DESC
LIMIT $1`, [limit]);
}
async function listClawbacksForExport(opts) {
const limit = Math.min(opts?.limit ?? 10000, 50000);
const conditions = [];
const values = [];
let i = 1;
if (opts?.from) {
conditions.push(`c.created_at >= $${i++}`);
values.push(opts.from);
}
if (opts?.to) {
conditions.push(`c.created_at <= $${i++}`);
values.push(opts.to);
}
const where = conditions.length ? `WHERE ${conditions.join(' AND ')}` : '';
values.push(limit);
return (0, connection_1.query)(`SELECT c.id, c.payout_id, c.beneficiary_user_id, p.referred_user_id, p.level_number,
p.commission_amount::text AS payout_commission_amount, c.amount::text, c.reason,
c.clawed_by, c.created_at, p.status AS payout_status
FROM referral_commission_clawbacks c
JOIN referral_commission_payouts p ON p.id = c.payout_id
${where}
ORDER BY c.created_at DESC
LIMIT $${i}`, values);
}
async function getFraudDashboardData() {
const summaryRows = await (0, connection_1.query)(`SELECT
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'pending')::text AS pending_count,
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'pending'), 0)::text AS pending_amount,
(SELECT COUNT(*) FROM referral_commission_payouts WHERE status = 'review')::text AS review_count,
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts WHERE status = 'review'), 0)::text AS review_amount,
(SELECT COUNT(*) FROM referral_commission_payouts
WHERE status = 'paid' AND COALESCE(paid_at, created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC'))::text AS paid_month_count,
COALESCE((SELECT SUM(commission_amount) FROM referral_commission_payouts
WHERE status = 'paid' AND COALESCE(paid_at, created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC')), 0)::text AS paid_month_amount,
(SELECT COUNT(*) FROM referral_commission_clawbacks
WHERE created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC'))::text AS clawed_month_count,
COALESCE((SELECT SUM(amount) FROM referral_commission_clawbacks
WHERE created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')), 0)::text AS clawed_month_amount`);
const blockedRows = await (0, connection_1.query)(`SELECT
(SELECT COUNT(*) FROM audit_logs
WHERE action = 'referral_commission_blocked'
AND created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC'))::text AS blocked_count,
(SELECT COUNT(*) FROM audit_logs
WHERE action = 'referral_commission_cap_blocked'
AND created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC'))::text AS cap_blocked_count`);
const sybilRows = await (0, connection_1.query)(`SELECT signal, COUNT(*)::text AS count
FROM referral_commission_payouts p,
LATERAL jsonb_array_elements_text(p.sybil_signals) AS signal
WHERE p.created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
AND p.status IN ('pending', 'review', 'paid', 'clawed_back')
GROUP BY signal
ORDER BY COUNT(*) DESC
LIMIT 20`);
const highRiskRows = await (0, connection_1.query)(`SELECT u.id AS user_id, u.referral_code,
COALESCE(AVG(p.sybil_score), 0)::text AS avg_sybil,
COUNT(*) FILTER (WHERE p.status = 'review')::text AS review_count,
COALESCE(SUM(p.commission_amount) FILTER (
WHERE p.status = 'paid'
AND COALESCE(p.paid_at, p.created_at) >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
), 0)::text AS paid_month_amount,
COALESCE(SUM(p.commission_amount) FILTER (
WHERE p.status IN ('pending', 'review', 'paid')
AND p.created_at >= date_trunc('month', NOW() AT TIME ZONE 'UTC')
), 0)::text AS reserved_month_amount,
(SELECT COUNT(*)::text FROM users r
WHERE r.referred_by_user_id = u.id
AND r.first_deposit_at IS NOT NULL
AND NOT EXISTS (
SELECT 1 FROM candle_predict_bets b
WHERE b.user_id = r.id AND b.stake_account_kind IN ('main', 'bonus')
)) AS inactive_referrals
FROM users u
LEFT JOIN referral_commission_payouts p ON p.beneficiary_user_id = u.id
WHERE u.referral_code IS NOT NULL
GROUP BY u.id, u.referral_code
HAVING COALESCE(AVG(p.sybil_score), 0) >= 2
OR COUNT(*) FILTER (WHERE p.status = 'review') > 0
OR (SELECT COUNT(*) FROM users r
WHERE r.referred_by_user_id = u.id
AND r.first_deposit_at IS NOT NULL
AND NOT EXISTS (
SELECT 1 FROM candle_predict_bets b
WHERE b.user_id = r.id AND b.stake_account_kind IN ('main', 'bonus')
)) >= 3
ORDER BY COALESCE(AVG(p.sybil_score), 0) DESC, COUNT(*) FILTER (WHERE p.status = 'review') DESC
LIMIT 15`);
const recentClawbacks = await listRecentClawbacks(15);
const clawbackCandidates = await (0, connection_1.query)(`SELECT id, beneficiary_user_id, referred_user_id, commission_amount::text,
paid_at, sybil_score
FROM referral_commission_payouts
WHERE status = 'paid'
ORDER BY COALESCE(paid_at, created_at) DESC
LIMIT 25`);
const capBlocks = await (0, connection_1.query)(`SELECT user_id, action, resource_id, metadata, created_at
FROM audit_logs
WHERE action IN ('referral_commission_cap_blocked', 'referral_commission_blocked')
ORDER BY created_at DESC
LIMIT 20`);
const summary = summaryRows[0];
const blocked = blockedRows[0];
return {
summary: {
pendingCount: Number(summary?.pending_count ?? 0),
pendingAmount: summary?.pending_amount ?? '0',
reviewCount: Number(summary?.review_count ?? 0),
reviewAmount: summary?.review_amount ?? '0',
paidThisMonthCount: Number(summary?.paid_month_count ?? 0),
paidThisMonthAmount: summary?.paid_month_amount ?? '0',
clawedBackThisMonthCount: Number(summary?.clawed_month_count ?? 0),
clawedBackThisMonthAmount: summary?.clawed_month_amount ?? '0',
blockedThisMonthCount: Number(blocked?.blocked_count ?? 0),
capBlockedThisMonthCount: Number(blocked?.cap_blocked_count ?? 0),
},
sybilSignalBreakdown: sybilRows.map((r) => ({ signal: r.signal, count: Number(r.count) })),
highRiskReferrers: highRiskRows.map((r) => ({
userId: r.user_id,
referralCode: r.referral_code,
avgSybilScore: Number(r.avg_sybil),
reviewCount: Number(r.review_count),
paidThisMonthAmount: r.paid_month_amount,
reservedThisMonthAmount: r.reserved_month_amount,
inactiveReferrals: Number(r.inactive_referrals),
})),
recentClawbacks: recentClawbacks.map((c) => ({
id: c.id,
payoutId: c.payout_id,
beneficiaryUserId: c.beneficiary_user_id,
amount: c.amount,
reason: c.reason,
clawedBy: c.clawed_by,
createdAt: c.created_at,
})),
recentCapBlocks: capBlocks.map((r) => ({
userId: r.user_id,
action: r.action,
resourceId: r.resource_id,
metadata: r.metadata ?? null,
createdAt: r.created_at,
})),
clawbackCandidates: clawbackCandidates.map((p) => ({
id: p.id,
beneficiaryUserId: p.beneficiary_user_id,
referredUserId: p.referred_user_id,
commissionAmount: p.commission_amount,
paidAt: p.paid_at,
sybilScore: p.sybil_score,
})),
};
}
//# sourceMappingURL=referralRepository.js.map