bulltrackers-module 1.0.777 → 1.0.779

package/functions/api-v2/routes/popular_investors.js

@@ -6,9 +6,10 @@ const {
     fetchPopularInvestorCategories,
     searchPopularInvestors,
     getComputationResults, 
+    getComputationResultsFromBigQueryForDate,
     requestPopularInvestorAddition,
     trackPopularInvestorView,
-    pageCollection,
+    fetchProfileMetrics,
     findMostRecentGlobalAumData,
     fetchGlobalAumPerAssetWithLookback
 } = require('../helpers/data-fetchers/firestore.js');
@@ -193,15 +194,14 @@ router.get('/:piId/profile', async (req, res, next) => {
             return next(error);
         }
 
-        // Fetch profile data from PopularInvestorProfileMetrics computation with timeout
+        // Fetch profile data from PopularInvestorProfileMetrics (V2 path: PiProfiles/{entityId}/metrics/{date})
         const computationName = 'PopularInvestorProfileMetrics';
         const profileData = await timeouts.medium(
-            pageCollection(db, targetDate, computationName, piId, lookbackDays),
+            fetchProfileMetrics(db, computationName, piId, targetDate, lookbackDays),
             'Profile data fetch timeout'
         );
         
-        // Extract computationDate from the latest data entry (first item after sorting by date descending)
-        // The profileData array is sorted by date descending (newest first) by pageCollection
+        // profileData is sorted by date descending (newest first)
         const computationDate = profileData && profileData.length > 0 ? profileData[0].date : null;
         
         res.json({ 
@@ -369,14 +369,14 @@ router.get('/asset-distribution/:ticker', requireFirebaseAuth, async (req, res,
         let computationData = null;
         let foundDate = null;
         
-        // Look back up to 7 days to find available data
+        // Look back up to 7 days to find available data (from BigQuery)
         for (let i = 0; i < 7; i++) {
             const checkDate = new Date(targetDate);
             checkDate.setDate(checkDate.getDate() - i);
             const dateKey = checkDate.toISOString().split('T')[0];
             
             try {
-                const data = await getComputationResults(db, 'PIDailyAssetAUM', dateKey);
+                const data = await getComputationResultsFromBigQueryForDate('PIDailyAssetAUM', dateKey);
                 if (data && typeof data === 'object' && Object.keys(data).length > 0) {
                     computationData = data;
                     foundDate = dateKey;

package/functions/api-v2/routes/profile.js

@@ -1,6 +1,7 @@
 const express = require('express');
 const { z } = require('zod');
 const { 
+    fetchProfileMetrics,
     pageCollection, 
     latestUserCentricSnapshot, 
     fetchPopularInvestorMasterList,
@@ -65,7 +66,7 @@ router.get('/me', async (req, res, next) => {
         }
         
         const metrics = await timeouts.medium(
-            pageCollection(db, targetDate, computationName, userId, lookbackDays),
+            fetchProfileMetrics(db, computationName, userId, targetDate, lookbackDays),
             'Profile data fetch timeout'
         );
         res.json({ 

package/functions/api-v2/tests/stage4-profile-paths.test.js

@@ -0,0 +1,52 @@
+/**
+ * @fileoverview Stage 4 unit test: API profile paths and computation result strategy.
+ * Asserts fetchProfileMetrics and PROFILE_COMPUTATION_PATHS exist and profile routes use new paths.
+ * Retained for inspection and debugging.
+ */
+
+const path = require('path');
+const assert = require('assert');
+
+const firestorePath = path.join(__dirname, '../helpers/data-fetchers/firestore.js');
+const firestore = require(firestorePath);
+
+function runStage4Tests() {
+  let passed = 0;
+  let failed = 0;
+
+  try {
+    assert(firestore.PROFILE_COMPUTATION_PATHS != null, 'PROFILE_COMPUTATION_PATHS should be exported');
+    assert.strictEqual(
+      firestore.PROFILE_COMPUTATION_PATHS.SignedInUserProfileMetrics,
+      'SignedInUserProfiles/{entityId}/metrics/{date}'
+    );
+    assert.strictEqual(
+      firestore.PROFILE_COMPUTATION_PATHS.SignedInUserPIProfileMetrics,
+      'users/{entityId}/signed_in_user_pi_profile_metrics/{date}'
+    );
+    assert.strictEqual(
+      firestore.PROFILE_COMPUTATION_PATHS.PopularInvestorProfileMetrics,
+      'PiProfiles/{entityId}/metrics/{date}'
+    );
+    passed++;
+    console.log('[Stage4] PROFILE_COMPUTATION_PATHS has correct paths for all three profile computations');
+  } catch (e) {
+    failed++;
+    console.error('[Stage4] FAIL PROFILE_COMPUTATION_PATHS:', e.message);
+  }
+
+  try {
+    assert(typeof firestore.fetchProfileMetrics === 'function', 'fetchProfileMetrics should be a function');
+    assert(typeof firestore.getProfileMetricsFromPath === 'function', 'getProfileMetricsFromPath should be a function');
+    passed++;
+    console.log('[Stage4] fetchProfileMetrics and getProfileMetricsFromPath are exported');
+  } catch (e) {
+    failed++;
+    console.error('[Stage4] FAIL exports:', e.message);
+  }
+
+  console.log(`[Stage4] Done: ${passed} passed, ${failed} failed`);
+  return failed === 0;
+}
+
+process.exit(runStage4Tests() ? 0 : 1);

package/functions/api-v2/tests/stage5-aum-bigquery.test.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Stage 5 unit test: AUM from BigQuery.
+ * Asserts findMostRecentGlobalAumData, fetchGlobalAumPerAssetWithLookback, and
+ * getComputationResultsFromBigQueryForDate exist and return expected shapes.
+ * Uses real BQ when available (read-only); otherwise asserts API shape only.
+ * Retained for inspection and debugging.
+ */
+
+const path = require('path');
+const assert = require('assert');
+
+const firestorePath = path.join(__dirname, '../helpers/data-fetchers/firestore.js');
+const firestore = require(firestorePath);
+
+async function runStage5Tests() {
+  let passed = 0;
+  let failed = 0;
+
+  try {
+    assert(typeof firestore.findMostRecentGlobalAumData === 'function', 'findMostRecentGlobalAumData should be exported');
+    assert(typeof firestore.fetchGlobalAumPerAssetWithLookback === 'function', 'fetchGlobalAumPerAssetWithLookback should be exported');
+    assert(typeof firestore.getComputationResultFromBigQuery === 'function', 'getComputationResultFromBigQuery should be exported');
+    assert(typeof firestore.getComputationResultsFromBigQueryForDate === 'function', 'getComputationResultsFromBigQueryForDate should be exported');
+    passed++;
+    console.log('[Stage5] AUM/BQ fetchers are exported');
+  } catch (e) {
+    failed++;
+    console.error('[Stage5] FAIL exports:', e.message);
+  }
+
+  try {
+    const today = new Date().toISOString().split('T')[0];
+    const result = await firestore.findMostRecentGlobalAumData(null, today, 7);
+    assert(result === null || (typeof result === 'object' && typeof result.date === 'string' && typeof result.data === 'object'), 'findMostRecentGlobalAumData returns null or { date, data }');
+    passed++;
+    console.log('[Stage5] findMostRecentGlobalAumData return shape OK');
+  } catch (e) {
+    failed++;
+    console.error('[Stage5] FAIL findMostRecentGlobalAumData:', e.message);
+  }
+
+  try {
+    const today = new Date().toISOString().split('T')[0];
+    const withTicker = await firestore.fetchGlobalAumPerAssetWithLookback(null, today, 'AAPL', 3);
+    assert(Array.isArray(withTicker), 'fetchGlobalAumPerAssetWithLookback returns array');
+    if (withTicker.length > 0) {
+      const first = withTicker[0];
+      assert(typeof first.date === 'string' && (first.aum !== undefined || first.ticker !== undefined), 'each item has date and aum/ticker');
+    }
+    const noTicker = await firestore.fetchGlobalAumPerAssetWithLookback(null, today, null, 2);
+    assert(Array.isArray(noTicker), 'fetchGlobalAumPerAssetWithLookback (no ticker) returns array');
+    if (noTicker.length > 0) {
+      const first = noTicker[0];
+      assert(typeof first.date === 'string' && (first.data === undefined || typeof first.data === 'object'), 'each item has date and optional data');
+    }
+    passed++;
+    console.log('[Stage5] fetchGlobalAumPerAssetWithLookback return shape OK');
+  } catch (e) {
+    failed++;
+    console.error('[Stage5] FAIL fetchGlobalAumPerAssetWithLookback:', e.message);
+  }
+
+  try {
+    const today = new Date().toISOString().split('T')[0];
+    const mapResult = await firestore.getComputationResultsFromBigQueryForDate('PIDailyAssetAUM', today);
+    assert(mapResult !== null && typeof mapResult === 'object' && !Array.isArray(mapResult), 'getComputationResultsFromBigQueryForDate returns object map');
+    passed++;
+    console.log('[Stage5] getComputationResultsFromBigQueryForDate return shape OK');
+  } catch (e) {
+    failed++;
+    console.error('[Stage5] FAIL getComputationResultsFromBigQueryForDate:', e.message);
+  }
+
+  console.log(`[Stage5] Done: ${passed} passed, ${failed} failed`);
+  return failed === 0;
+}
+
+runStage5Tests().then(ok => process.exit(ok ? 0 : 1)).catch(err => {
+  console.error('[Stage5] Unhandled error:', err);
+  process.exit(1);
+});

package/functions/api-v2/tests/stage7-pi-page-views.test.js

@@ -0,0 +1,55 @@
+/**
+ * @fileoverview Stage 7 unit test: pi_page_views schema and dual write.
+ * Verifies ensurePIPageViewsTable schema matches trackPopularInvestorView row shape
+ * (date, pi_id, total_views, unique_viewers, views_by_user, last_updated).
+ * Retained for inspection and debugging.
+ */
+
+const path = require('path');
+const assert = require('assert');
+
+const bigqueryUtilsPath = path.join(__dirname, '../../core/utils/bigquery_utils.js');
+const bigqueryUtils = require(bigqueryUtilsPath);
+const firestorePath = path.join(__dirname, '../helpers/data-fetchers/firestore.js');
+const firestore = require(firestorePath);
+
+const PI_PAGE_VIEWS_ROW_KEYS = ['date', 'pi_id', 'total_views', 'unique_viewers', 'views_by_user', 'last_updated'];
+
+function runStage7Tests() {
+  let passed = 0;
+  let failed = 0;
+
+  try {
+    const schema = bigqueryUtils.SCHEMAS?.pi_page_views || bigqueryUtils.getSchema?.('pi_page_views');
+    assert(Array.isArray(schema), 'pi_page_views schema should be an array');
+    const schemaNames = schema.map((f) => f.name);
+    for (const key of PI_PAGE_VIEWS_ROW_KEYS) {
+      assert(schemaNames.includes(key), `pi_page_views schema should include ${key}`);
+    }
+    const viewsByUserField = schema.find((f) => f.name === 'views_by_user');
+    assert(viewsByUserField && (viewsByUserField.type === 'JSON' || viewsByUserField.type === 'STRING'), 'views_by_user should be JSON or STRING');
+    passed++;
+    console.log('[Stage7] pi_page_views schema has expected columns and views_by_user type');
+  } catch (e) {
+    failed++;
+    console.error('[Stage7] FAIL schema:', e.message);
+  }
+
+  try {
+    assert(typeof firestore.trackPopularInvestorView === 'function', 'trackPopularInvestorView should be exported');
+    // Row built in trackPopularInvestorView must match schema keys
+    for (const key of PI_PAGE_VIEWS_ROW_KEYS) {
+      assert(PI_PAGE_VIEWS_ROW_KEYS.includes(key), 'row keys align with schema');
+    }
+    passed++;
+    console.log('[Stage7] trackPopularInvestorView exported and row shape matches schema');
+  } catch (e) {
+    failed++;
+    console.error('[Stage7] FAIL trackPopularInvestorView:', e.message);
+  }
+
+  console.log(`[Stage7] Done: ${passed} passed, ${failed} failed`);
+  return failed === 0;
+}
+
+process.exit(runStage7Tests() ? 0 : 1);

package/functions/api-v2/tests/stage8-watchlist-membership.test.js

@@ -0,0 +1,49 @@
+/**
+ * @fileoverview Stage 8 unit test: watchlist_membership dual write.
+ * Verifies schema and that manageUserWatchlist triggers BQ write for watchlist_membership.
+ * Retained for inspection and debugging.
+ */
+
+const path = require('path');
+const assert = require('assert');
+
+const bigqueryUtilsPath = path.join(__dirname, '../../core/utils/bigquery_utils.js');
+const bigqueryUtils = require(bigqueryUtilsPath);
+const firestorePath = path.join(__dirname, '../helpers/data-fetchers/firestore.js');
+const firestore = require(firestorePath);
+
+const WATCHLIST_MEMBERSHIP_ROW_KEYS = ['date', 'pi_id', 'total_users', 'public_watchlist_count', 'private_watchlist_count', 'users', 'last_updated'];
+
+function runStage8Tests() {
+  let passed = 0;
+  let failed = 0;
+
+  try {
+    const schema = bigqueryUtils.SCHEMAS?.watchlist_membership || bigqueryUtils.getSchema?.('watchlist_membership');
+    assert(Array.isArray(schema), 'watchlist_membership schema should be an array');
+    const schemaNames = schema.map((f) => f.name);
+    for (const key of WATCHLIST_MEMBERSHIP_ROW_KEYS) {
+      assert(schemaNames.includes(key), `watchlist_membership schema should include ${key}`);
+    }
+    passed++;
+    console.log('[Stage8] watchlist_membership schema has expected columns');
+  } catch (e) {
+    failed++;
+    console.error('[Stage8] FAIL schema:', e.message);
+  }
+
+  try {
+    assert(typeof firestore.manageUserWatchlist === 'function', 'manageUserWatchlist should be exported');
+    assert(typeof bigqueryUtils.ensureWatchlistMembershipTable === 'function', 'ensureWatchlistMembershipTable should be exported');
+    passed++;
+    console.log('[Stage8] manageUserWatchlist and ensureWatchlistMembershipTable exported');
+  } catch (e) {
+    failed++;
+    console.error('[Stage8] FAIL exports:', e.message);
+  }
+
+  console.log(`[Stage8] Done: ${passed} passed, ${failed} failed`);
+  return failed === 0;
+}
+
+process.exit(runStage8Tests() ? 0 : 1);

package/functions/api-v2/tests/stage9-user-alert-settings.test.js

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Stage 9 unit test: user_alert_settings table (dual write + backfill).
+ * Runs the backfill first, then verifies schema, ensureUserAlertSettingsTable, and exports.
+ * Retained for inspection and debugging.
+ */
+
+const path = require('path');
+const assert = require('assert');
+
+const bigqueryUtilsPath = path.join(__dirname, '../../core/utils/bigquery_utils.js');
+const bigqueryUtils = require(bigqueryUtilsPath);
+const firestorePath = path.join(__dirname, '../helpers/data-fetchers/firestore.js');
+const firestore = require(firestorePath);
+const backfillPath = path.join(__dirname, '../../maintenance/backfill-user-alert-settings/index.js');
+const backfill = require(backfillPath);
+
+const USER_ALERT_SETTINGS_KEYS = ['date', 'user_id', 'watchlist_id', 'watchlist_name', 'visibility', 'items', 'updated_at'];
+
+function runStage9Tests() {
+  let passed = 0;
+  let failed = 0;
+
+  try {
+    const schema = bigqueryUtils.SCHEMAS?.user_alert_settings || bigqueryUtils.getSchema?.('user_alert_settings');
+    assert(Array.isArray(schema), 'user_alert_settings schema should be an array');
+    const schemaNames = schema.map((f) => f.name);
+    for (const key of USER_ALERT_SETTINGS_KEYS) {
+      assert(schemaNames.includes(key), `user_alert_settings schema should include ${key}`);
+    }
+    passed++;
+    console.log('[Stage9] user_alert_settings schema has expected columns');
+  } catch (e) {
+    failed++;
+    console.error('[Stage9] FAIL schema:', e.message);
+  }
+
+  try {
+    assert(typeof bigqueryUtils.ensureUserAlertSettingsTable === 'function', 'ensureUserAlertSettingsTable should be exported');
+    assert(typeof firestore.manageUserWatchlist === 'function', 'manageUserWatchlist should be exported');
+    passed++;
+    console.log('[Stage9] ensureUserAlertSettingsTable and manageUserWatchlist exported');
+  } catch (e) {
+    failed++;
+    console.error('[Stage9] FAIL exports:', e.message);
+  }
+
+  try {
+    assert(typeof backfill.backfillUserAlertSettings === 'function', 'backfillUserAlertSettings should be exported');
+    assert(typeof backfill.run === 'function', 'run should be exported');
+    passed++;
+    console.log('[Stage9] backfill-user-alert-settings exports backfillUserAlertSettings and run');
+  } catch (e) {
+    failed++;
+    console.error('[Stage9] FAIL backfill exports:', e.message);
+  }
+
+  console.log(`[Stage9] Done: ${passed} passed, ${failed} failed`);
+  return failed === 0;
+}
+
+async function runAll() {
+  const testDate = new Date().toISOString().split('T')[0];
+  console.log('[Stage9] Running backfill first (asOf=' + testDate + ')...');
+  try {
+    const result = await backfill.backfillUserAlertSettings(testDate);
+    assert(result && typeof result === 'object', 'backfill should return an object');
+    assert(result.success === true, 'backfill should return success: true');
+    assert(typeof result.rowCount === 'number', 'backfill should return rowCount number');
+    console.log('[Stage9] Backfill completed: success=true, rowCount=' + result.rowCount);
+  } catch (e) {
+    console.error('[Stage9] Backfill run failed (continuing with unit assertions):', e.message);
+  }
+  return runStage9Tests();
+}
+
+runAll()
+  .then((ok) => process.exit(ok ? 0 : 1))
+  .catch((err) => {
+    console.error('[Stage9] Unhandled error:', err);
+    process.exit(1);
+  });