bulltrackers-module 1.0.913 → 1.0.915

package/functions/api-v3/middleware/identity.js

@@ -39,6 +39,7 @@ function createIdentityMiddleware() {
                 if (/^\/alerts\b/.test(p)) return true;
                 // User settings/profile
                 if (/^\/profile\b/.test(p)) return true;
+                if (/^\/dashboard\b/.test(p)) return true;
                 if (/^\/settings\b/.test(p)) return true;
                 return false;
             };

package/functions/api-v3/routes/dashboard.js

@@ -0,0 +1,276 @@
+/**
+ * @fileoverview Dashboard Routes
+ * Serves dashboard page data: global computation result (DashboardPage) plus
+ * signed-in user's alerts from Firestore. Frontend uses toggle for "my alerts" vs "all" (recentAlertEvents).
+ * Also handles on-demand sync to re-run stale computations (> 2 days old).
+ */
+
+const { createRoute, createRouter, z } = require('../core/route-factory');
+const { requireTargetUser } = require('../middleware/identity');
+
+const today = () => new Date().toISOString().split('T')[0];
+const toDayString = (d) => d.toISOString().split('T')[0];
+const DASHBOARD_COMPUTATION_NAME = 'dashboardpage';
+const DEFAULT_LOOKBACK_DAYS = 7;
+const USER_ALERTS_LIMIT = 100;
+const STALE_DAYS_THRESHOLD = 2;
+const SYNC_JOB_TIMEOUT_MINS = 30;
+
+const calculateDaysOld = (computationDate) => {
+    if (!computationDate) return null;
+    const compDate = new Date(`${computationDate}T00:00:00Z`);
+    const todayDate = new Date();
+    // Normalize today to UTC midnight
+    const todayUTC = new Date(Date.UTC(todayDate.getUTCFullYear(), todayDate.getUTCMonth(), todayDate.getUTCDate()));
+    const diffMs = todayUTC.getTime() - compDate.getTime();
+    const daysOld = Math.floor(diffMs / (24 * 60 * 60 * 1000));
+    return Math.max(0, daysOld);
+};
+
+const getSyncJobPath = (userId, jobId) => {
+    return `SyncJobs/${userId}/dashboardpage/${jobId}`;
+};
+
+
+const emptyDashboardData = () => ({
+    topPIRiskChange7d: [],
+    mostPurchasedAssets: [],
+    mostSoldAssets: [],
+    mostOwnedAssetsWithAum: [],
+    totalAum: 0,
+    recentAlertEvents: []
+});
+
+const routes = [
+    createRoute({
+        method: 'GET',
+        path: '/',
+        summary: 'Get dashboard data for the signed-in user',
+        tags: ['Dashboard'],
+        middleware: [requireTargetUser],
+        validation: {
+            query: z.object({
+                date: z.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional().default(today),
+                lookback: z.union([z.string().regex(/^\d+$/).transform(Number), z.number()])
+                    .pipe(z.number().min(1).max(30)).optional().default(DEFAULT_LOOKBACK_DAYS)
+            }),
+            context: z.object({
+                targetUserId: z.string().describe('The signed-in user ID')
+            })
+        },
+        handler: async (req, res, next) => {
+            try {
+                const { computationReader, userDataService } = req.services;
+                const { date, lookback } = req.validated.query;
+                const { targetUserId } = req.validated.context;
+
+                const [lookbackResult, userAlerts] = await Promise.all([
+                    computationReader.getResultWithLookback(DASHBOARD_COMPUTATION_NAME, date, null, lookback),
+                    userDataService.getUserAlerts(targetUserId, { limit: USER_ALERTS_LIMIT })
+                ]);
+
+                const computationDate = lookbackResult?.date || null;
+                const daysOld = calculateDaysOld(computationDate);
+                const canSync = daysOld !== null && daysOld >= STALE_DAYS_THRESHOLD;
+
+                const resultPayload = lookbackResult?.data?.result ?? lookbackResult?.data ?? null;
+                const data = resultPayload && typeof resultPayload === 'object'
+                    ? {
+                        topPIRiskChange7d: resultPayload.topPIRiskChange7d ?? [],
+                        mostPurchasedAssets: resultPayload.mostPurchasedAssets ?? [],
+                        mostSoldAssets: resultPayload.mostSoldAssets ?? [],
+                        mostOwnedAssetsWithAum: resultPayload.mostOwnedAssetsWithAum ?? [],
+                        totalAum: resultPayload.totalAum ?? 0,
+                        recentAlertEvents: resultPayload.recentAlertEvents ?? []
+                    }
+                    : emptyDashboardData();
+
+                const userAlertCount = userAlerts.filter(a => a.read !== true).length;
+
+                res.json({
+                    success: true,
+                    computationDate,
+                    daysOld,
+                    canSync,
+                    data,
+                    userAlerts,
+                    userAlertCount
+                });
+            } catch (error) {
+                next(error);
+            }
+        }
+    }),
+    // POST /sync - Request on-demand sync for stale computation
+    createRoute({
+        method: 'POST',
+        path: '/sync',
+        summary: 'Request on-demand sync for dashboard computation if data is stale (> 2 days)',
+        tags: ['Dashboard'],
+        middleware: [requireTargetUser],
+        validation: {
+            context: z.object({
+                targetUserId: z.string().describe('The signed-in user ID')
+            })
+        },
+        handler: async (req, res, next) => {
+            try {
+                const { computationReader, computationSystemClient, db } = req.services;
+                const { targetUserId } = req.validated.context;
+
+                // Check current computation date
+                const lookbackResult = await computationReader.getResultWithLookback(
+                    DASHBOARD_COMPUTATION_NAME,
+                    today(),
+                    null,
+                    DEFAULT_LOOKBACK_DAYS
+                );
+
+                const computationDate = lookbackResult?.date || null;
+                const daysOld = calculateDaysOld(computationDate);
+
+                // Check if stale
+                if (daysOld === null || daysOld < STALE_DAYS_THRESHOLD) {
+                    return res.status(400).json({
+                        success: false,
+                        error: 'Data is not stale enough for sync',
+                        daysOld,
+                        staleDaysRequired: STALE_DAYS_THRESHOLD,
+                        computationDate
+                    });
+                }
+
+                // Enqueue on-demand computation request
+                const targetDate = today();
+                const jobId = `sync-dashboardpage-${targetUserId}-${Date.now()}`;
+                
+                const triggerResult = await computationSystemClient.triggerOnDemandRequest({
+                    computation: DASHBOARD_COMPUTATION_NAME,
+                    targetDate,
+                    entityIds: ['_global'],
+                    allowToday: true,
+                    requestKind: 'user_sync_request',
+                    metadata: {
+                        userId: targetUserId,
+                        syncJobId: jobId,
+                        userType: 'SIGNED_IN_USER'
+                    }
+                });
+
+                if (!triggerResult.success) {
+                    return res.status(500).json({
+                        success: false,
+                        error: 'Failed to enqueue computation task',
+                        detail: triggerResult.error
+                    });
+                }
+
+                // Write job status to Firestore
+                const jobRef = db.doc(getSyncJobPath(targetUserId, jobId));
+                await jobRef.set({
+                    status: 'queued',
+                    createdAt: new Date(),
+                    computationName: DASHBOARD_COMPUTATION_NAME,
+                    targetDate,
+                    daysOld,
+                    userId: targetUserId
+                });
+
+                res.json({
+                    success: true,
+                    jobId,
+                    status: 'queued',
+                    eta: '5-10 minutes',
+                    computationDate
+                });
+            } catch (error) {
+                next(error);
+            }
+        }
+    }),
+    // GET /sync/status/:jobId - Poll sync job status
+    createRoute({
+        method: 'GET',
+        path: '/sync/status/:jobId',
+        summary: 'Check status of a dashboard sync job',
+        tags: ['Dashboard'],
+        middleware: [requireTargetUser],
+        validation: {
+            params: z.object({
+                jobId: z.string().describe('The sync job ID')
+            }),
+            context: z.object({
+                targetUserId: z.string().describe('The signed-in user ID')
+            })
+        },
+        handler: async (req, res, next) => {
+            try {
+                const { computationReader, db } = req.services;
+                const { jobId } = req.validated.params;
+                const { targetUserId } = req.validated.context;
+
+                // Read job status from Firestore
+                const jobRef = db.doc(getSyncJobPath(targetUserId, jobId));
+                const jobDoc = await jobRef.get();
+
+                if (!jobDoc.exists) {
+                    return res.status(404).json({
+                        success: false,
+                        error: 'Sync job not found'
+                    });
+                }
+
+                const jobData = jobDoc.data();
+                const createdAt = jobData.createdAt?.toDate ? jobData.createdAt.toDate() : new Date(jobData.createdAt);
+                const elapsedMs = Date.now() - createdAt.getTime();
+                const timedOut = elapsedMs > SYNC_JOB_TIMEOUT_MINS * 60 * 1000;
+
+                if (timedOut && (jobData.status === 'queued' || jobData.status === 'running')) {
+                    // Mark as failed due to timeout
+                    await jobRef.update({ status: 'failed', error: 'Computation timeout' });
+                    return res.json({
+                        success: true,
+                        jobId,
+                        status: 'failed',
+                        error: 'Computation timeout (exceeded 30 minutes)'
+                    });
+                }
+
+                // Check if newer result exists in BQ
+                if (jobData.status !== 'completed') {
+                    const latestResult = await computationReader.getResultWithLookback(
+                        DASHBOARD_COMPUTATION_NAME,
+                        today(),
+                        null,
+                        1 // Just check today's result
+                    );
+
+                    // If result date is newer than job creation, computation succeeded
+                    if (latestResult?.date && new Date(`${latestResult.date}T00:00:00Z`).getTime() >= createdAt.getTime()) {
+                        // Mark as completed
+                        await jobRef.update({ status: 'completed', resultDate: latestResult.date });
+                        return res.json({
+                            success: true,
+                            jobId,
+                            status: 'completed',
+                            resultDate: latestResult.date
+                        });
+                    }
+                }
+
+                // Still running or already completed
+                res.json({
+                    success: true,
+                    jobId,
+                    status: jobData.status || 'running',
+                    eta: jobData.status === 'completed' ? null : `${Math.ceil((30 * 60 * 1000 - elapsedMs) / 60000)} minutes remaining`,
+                    resultDate: jobData.resultDate || null
+                });
+            } catch (error) {
+                next(error);
+            }
+        }
+    })
+];
+
+module.exports = createRouter(routes);

package/functions/api-v3/routes/index.js

@@ -21,6 +21,7 @@ const createComputationsRouter = require('./computations');
 const createWorkspaceRouter = require('./workspace');
 const runsRoutes = require('./runs');
 const logsRoutes = require('./logs');
+const dashboardRoutes = require('./dashboard');
 
 /**
  * Create and configure all API routes.
@@ -43,6 +44,7 @@ function createRoutes() {
     router.use('/billing', billingRoutes);
     router.use('/computations', createComputationsRouter());
     router.use('/workspace', createWorkspaceRouter());
+    router.use('/dashboard', dashboardRoutes);
     router.use('/runs', runsRoutes);
     router.use('/logs', logsRoutes);
 

package/functions/computation-system-v3/computations/DashboardPage.js

@@ -0,0 +1,224 @@
+/**
+ * @fileoverview Dashboard Page Computation (V3)
+ * Global aggregation: top PI risk change (7d), most purchased/sold assets,
+ * most commonly owned assets with AUM, total AUM, and recent PI alert events.
+ */
+
+/** @typedef {import('../framework/core/ContextBuilder').ComputationContext} ComputationContext */
+
+const TOP_RISK_CHANGE_N = 20;
+const TOP_ASSETS_N = 30;
+const RECENT_ALERTS_LIMIT = 50;
+
+exports.config = {
+    name: 'DashboardPage',
+    type: 'global',
+    category: 'market_insights',
+    skills: ['lib', 'bigquery'],
+
+    requires: {
+        'pi_rankings': {
+            lookback: 7,
+            mandatory: true,
+            fields: ['pi_id', 'username', 'rankings_data', 'date']
+        },
+        'trade_history_snapshots': {
+            lookback: 7,
+            mandatory: true,
+            fields: ['user_id', 'history_data', 'date'],
+            filter: { user_type: 'POPULAR_INVESTOR' }
+        },
+        'portfolio_snapshots': {
+            lookback: 0,
+            mandatory: false,
+            fields: ['user_id', 'portfolio_data', 'date'],
+            filter: { user_type: 'POPULAR_INVESTOR' }
+        },
+        'pi_alert_history': {
+            lookback: 7,
+            mandatory: false,
+            fields: ['date', 'pi_id', 'alert_type', 'triggered', 'trigger_count', 'last_triggered', 'last_updated']
+        },
+        'ticker_mappings': {
+            lookback: 0,
+            mandatory: false,
+            fields: ['instrument_id', 'ticker']
+        },
+        'results': {
+            lookback: 0,
+            mandatory: false,
+            fields: ['result_data', 'computation_name', 'date', 'entity_id'],
+            filter: { computation_name: 'globalaumperasset30d' }
+        }
+    },
+
+    dependencies: ['globalaumperasset30d'],
+
+    storage: {
+        bigquery: true
+    }
+};
+
+/**
+ * @param {ComputationContext} ctx
+ */
+exports.process = (ctx) => {
+    const { data, date, lib } = ctx;
+
+    const toArray = (input) => {
+        if (!input) return [];
+        if (Array.isArray(input)) return input;
+        return Object.values(input).flat();
+    };
+
+    const rankings = toArray(data['pi_rankings'] || []);
+    const tradeHistory = toArray(data['trade_history_snapshots'] || []);
+    const alertHistory = toArray(data['pi_alert_history'] || []);
+    const tickerRows = toArray(data['ticker_mappings'] || []);
+
+    const tickerMap = new Map();
+    tickerRows.forEach(row => {
+        if (row.instrument_id != null && row.ticker) {
+            tickerMap.set(Number(row.instrument_id), String(row.ticker).toUpperCase());
+        }
+    });
+    const resolveTicker = (instrumentId) => tickerMap.get(Number(instrumentId)) || `ID:${instrumentId}`;
+
+    const usernameByPiId = new Map();
+    rankings.forEach(r => {
+        const id = r.pi_id != null ? String(r.pi_id) : null;
+        if (id) usernameByPiId.set(id, r.username || r.UserName || null);
+    });
+
+    // -------------------------------------------------------------------------
+    // 1. Top PI risk change (7d)
+    // -------------------------------------------------------------------------
+    const riskByPi = new Map();
+    rankings.forEach(row => {
+        const piId = row.pi_id != null ? String(row.pi_id) : null;
+        if (!piId) return;
+        const rData = lib.rankings.extractRankingsData(row);
+        const risk = rData != null ? lib.rankings.getRiskScore(rData) : 0;
+        const dateStr = row.date && (typeof row.date.value === 'string' ? row.date.value : String(row.date).slice(0, 10));
+        if (!dateStr) return;
+        if (!riskByPi.has(piId)) riskByPi.set(piId, []);
+        riskByPi.get(piId).push({ date: dateStr, risk });
+    });
+
+    const topPIRiskChange7d = [];
+    riskByPi.forEach((points, piId) => {
+        if (points.length < 2) return;
+        points.sort((a, b) => a.date.localeCompare(b.date));
+        const first = points[0].risk;
+        const last = points[points.length - 1].risk;
+        const change = last - first;
+        topPIRiskChange7d.push({
+            piId,
+            username: usernameByPiId.get(piId) || 'Unknown',
+            change: Number(change.toFixed(2))
+        });
+    });
+    topPIRiskChange7d.sort((a, b) => Math.abs(b.change) - Math.abs(a.change));
+    const topPIRiskChange7dSlice = topPIRiskChange7d.slice(0, TOP_RISK_CHANGE_N);
+
+    // -------------------------------------------------------------------------
+    // 2. Most purchased / most sold assets (from trade_history_snapshots)
+    // -------------------------------------------------------------------------
+    const purchaseCount = new Map();
+    const saleCount = new Map();
+
+    tradeHistory.forEach(row => {
+        const trades = lib.trades.extractTrades(row);
+        trades.forEach(trade => {
+            const instrumentId = lib.trades.getInstrumentId(trade);
+            if (instrumentId == null) return;
+            const ticker = resolveTicker(instrumentId);
+            if (lib.trades.isBuy(trade)) {
+                purchaseCount.set(ticker, (purchaseCount.get(ticker) || 0) + 1);
+            } else {
+                saleCount.set(ticker, (saleCount.get(ticker) || 0) + 1);
+            }
+        });
+    });
+
+    const mostPurchasedAssets = Array.from(purchaseCount.entries())
+        .map(([ticker, count]) => ({ ticker, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, TOP_ASSETS_N);
+
+    const mostSoldAssets = Array.from(saleCount.entries())
+        .map(([ticker, count]) => ({ ticker, count }))
+        .sort((a, b) => b.count - a.count)
+        .slice(0, TOP_ASSETS_N);
+
+    // -------------------------------------------------------------------------
+    // 3. Most commonly owned assets + AUM (from GlobalAumPerAsset30D result)
+    // -------------------------------------------------------------------------
+    let mostOwnedAssetsWithAum = [];
+    const resultsRows = toArray(data['results'] || []);
+    for (const row of resultsRows) {
+        if (row.entity_id !== '_global') continue;
+        let resultData = row.result_data;
+        if (typeof resultData === 'string') {
+            try { resultData = JSON.parse(resultData); } catch (_) { continue; }
+        }
+        const arr = Array.isArray(resultData) ? resultData : (resultData && resultData.result);
+        if (Array.isArray(arr)) {
+            mostOwnedAssetsWithAum = arr
+                .filter(x => x && (x.symbol || x.ticker) && (x.amount != null))
+                .map(x => ({ symbol: x.symbol || x.ticker, amount: Number(x.amount) }));
+            break;
+        }
+    }
+
+    // -------------------------------------------------------------------------
+    // 4. Total AUM (latest date in rankings window)
+    // -------------------------------------------------------------------------
+    const dates = [...new Set(rankings.map(r => {
+        const d = r.date;
+        return d && (typeof d.value === 'string' ? d.value : String(d).slice(0, 10));
+    }).filter(Boolean))].sort();
+    const latestDate = dates.length ? dates[dates.length - 1] : date;
+
+    let totalAum = 0;
+    rankings.forEach(row => {
+        const d = row.date;
+        const dateStr = d && (typeof d.value === 'string' ? d.value : String(d).slice(0, 10));
+        if (dateStr !== latestDate) return;
+        const rData = lib.rankings.extractRankingsData(row);
+        if (rData) totalAum += lib.rankings.getAUM(rData) || 0;
+    });
+    totalAum = Number(totalAum.toFixed(2));
+
+    // -------------------------------------------------------------------------
+    // 5. Recent alert events (all) — normalized for API
+    // -------------------------------------------------------------------------
+    const recentAlertEvents = lib.dashboardParsing
+        ? lib.dashboardParsing.normalizeRecentAlertEvents(alertHistory, RECENT_ALERTS_LIMIT)
+        : alertHistory.slice(0, RECENT_ALERTS_LIMIT).map(row => ({
+            date: row.date && (typeof row.date.value === 'string' ? row.date.value : String(row.date).slice(0, 10)),
+            pi_id: row.pi_id != null ? Number(row.pi_id) : null,
+            alert_type: row.alert_type || null,
+            trigger_count: row.trigger_count != null ? Number(row.trigger_count) : null,
+            last_triggered: row.last_triggered
+        }));
+
+    // Attach username to each alert event when available
+    recentAlertEvents.forEach(ev => {
+        if (ev.pi_id != null && usernameByPiId.has(String(ev.pi_id))) {
+            ev.username = usernameByPiId.get(String(ev.pi_id));
+        }
+    });
+
+    return {
+        outcome: 'completed',
+        result: {
+            topPIRiskChange7d: topPIRiskChange7dSlice,
+            mostPurchasedAssets,
+            mostSoldAssets,
+            mostOwnedAssetsWithAum,
+            totalAum,
+            recentAlertEvents
+        }
+    };
+};

package/functions/computation-system-v3/config/bulltrackers.config.js

@@ -329,7 +329,8 @@ module.exports = {
                 'trades',
                 'social',
                 'instruments',
-                'metrics'
+                'metrics',
+                'dashboardParsing'
             ]
         }
     },

package/functions/computation-system-v3/framework/lib/dashboardParsing.js

@@ -0,0 +1,72 @@
+/**
+ * @fileoverview Dashboard parsing and normalization helpers.
+ * Normalizes pi_alert_history rows and optional trade/portfolio aggregates
+ * for the DashboardPage computation and consistent API payload shape.
+ * Factory pattern: module.exports = () => ({ ... }) for ctx.lib.dashboardParsing.
+ */
+
+module.exports = () => {
+/**
+ * Normalize a single pi_alert_history row for dashboard display.
+ * @param {Object} row - Raw row from BigQuery (date, pi_id, alert_type, trigger_count, last_triggered, etc.)
+ * @returns {Object} Normalized shape: { date, pi_id, alert_type, trigger_count, last_triggered }
+ */
+function normalizeAlertEvent(row) {
+    if (!row) return null;
+    const toDateStr = (v) => {
+        if (!v) return null;
+        if (typeof v === 'string') return v.slice(0, 10);
+        if (v.value) return String(v.value).slice(0, 10);
+        if (v instanceof Date) return v.toISOString().slice(0, 10);
+        if (typeof v.toDate === 'function') return v.toDate().toISOString().slice(0, 10);
+        return null;
+    };
+    const toIso = (v) => {
+        if (!v) return null;
+        if (typeof v === 'string') return v;
+        if (v instanceof Date) return v.toISOString();
+        if (typeof v.toDate === 'function') return v.toDate().toISOString();
+        if (typeof v === 'object' && typeof v._seconds === 'number') {
+            const ms = v._seconds * 1000 + Math.floor((v._nanoseconds || 0) / 1e6);
+            return new Date(ms).toISOString();
+        }
+        return null;
+    };
+    return {
+        date: toDateStr(row.date),
+        pi_id: row.pi_id != null ? Number(row.pi_id) : null,
+        alert_type: row.alert_type || null,
+        triggered: row.triggered,
+        trigger_count: row.trigger_count != null ? Number(row.trigger_count) : null,
+        last_triggered: toIso(row.last_triggered),
+        last_updated: toIso(row.last_updated)
+    };
+}
+
+/**
+ * Normalize an array of pi_alert_history rows and sort by last_triggered desc.
+ * @param {Array|Object} rows - Rows from framework data (array or entity-keyed object)
+ * @param {number} limit - Max items to return
+ * @returns {Array<Object>} Normalized array, most recent first
+ */
+function normalizeRecentAlertEvents(rows, limit = 50) {
+    const toArray = (input) => {
+        if (!input) return [];
+        if (Array.isArray(input)) return input;
+        return Object.values(input).flat();
+    };
+    const arr = toArray(rows);
+    const normalized = arr.map(normalizeAlertEvent).filter(Boolean);
+    const withTimestamp = normalized.map((n) => ({
+        ...n,
+        _sort: n.last_triggered ? new Date(n.last_triggered).getTime() : 0
+    }));
+    withTimestamp.sort((a, b) => b._sort - a._sort);
+    return withTimestamp.slice(0, limit).map(({ _sort, ...rest }) => rest);
+}
+
+return {
+    normalizeAlertEvent,
+    normalizeRecentAlertEvents
+};
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bulltrackers-module",
-  "version": "1.0.913",
+  "version": "1.0.915",
   "description": "Helper Functions for Bulltrackers.",
   "main": "index.js",
   "files": [