bulltrackers-module 1.0.795 → 1.0.797

package/functions/alert-system-v3/adapters/MembershipRepo.js

@@ -0,0 +1,27 @@
+'use strict';
+
+class MembershipRepo {
+  constructor(dependencies, config) {
+    this.db = dependencies.db;
+    this.logger = dependencies.logger;
+    this.config = config;
+  }
+
+  async getUserCidsForPi(date, piCid) {
+    if (!date || piCid == null) return [];
+    const col = this.config.collections.watchlistMembership;
+    try {
+      const doc = await this.db.collection(col).doc(date).get();
+      if (!doc.exists) return [];
+      const data = doc.data();
+      const entry = data[String(piCid)] || data[Number(piCid)];
+      if (!entry || !Array.isArray(entry.users)) return [];
+      return entry.users.map(cid => String(cid));
+    } catch (error) {
+      this.logger?.log('WARN', `[MembershipRepo] Failed to read membership for ${piCid} on ${date}: ${error.message}`);
+      return [];
+    }
+  }
+}
+
+module.exports = { MembershipRepo };

package/functions/alert-system-v3/adapters/NotificationBus.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { PubSubUtils } = require('../../core/utils/pubsub_utils');
+
+class NotificationBus {
+  constructor(dependencies, config) {
+    this.pubsubUtils = dependencies.pubsubUtils || new PubSubUtils(dependencies);
+    this.config = config;
+  }
+
+  async publishRawEvent(payload) {
+    return this.pubsubUtils.publish(this.config.topics.raw, payload);
+  }
+
+  async publishNotifications(notifications) {
+    return this.pubsubUtils.batchPublishTasks({
+      topicName: this.config.topics.notify,
+      tasks: notifications,
+      taskType: 'alert-notifications',
+      maxPubsubBatchSize: 200
+    });
+  }
+
+  async publishHistoryEvents(events) {
+    return this.pubsubUtils.batchPublishTasks({
+      topicName: this.config.topics.history,
+      tasks: events,
+      taskType: 'alert-history',
+      maxPubsubBatchSize: 200
+    });
+  }
+}
+
+module.exports = { NotificationBus };

package/functions/alert-system-v3/adapters/UserConfigRepo.js

@@ -0,0 +1,104 @@
+'use strict';
+
+const { isDeveloper, manageNotificationPreferences, fetchPopularInvestorMasterList } = require('../../api-v2/helpers/data-fetchers/firestore');
+
+class UserConfigRepo {
+  constructor(dependencies, config) {
+    this.db = dependencies.db;
+    this.logger = dependencies.logger;
+    this.config = config;
+  }
+
+  async getSubscriptionsForPi({ piCid, userCids, alertType }) {
+    const subscriptions = [];
+    if (!piCid || !Array.isArray(userCids) || userCids.length === 0) return subscriptions;
+
+    const piUsername = await this._resolvePiUsername(piCid);
+
+    for (const userCidStr of userCids) {
+      const userCid = Number(userCidStr);
+      const watchlistsSnap = await this.db
+        .collection(this.config.collections.signedInUsers)
+        .doc(String(userCid))
+        .collection('watchlists')
+        .get();
+
+      if (watchlistsSnap.empty) continue;
+
+      for (const doc of watchlistsSnap.docs) {
+        const watchlist = { id: doc.id, ...doc.data() };
+        if (watchlist.type !== 'static' || !Array.isArray(watchlist.items)) continue;
+
+        for (const item of watchlist.items) {
+          if (Number(item.cid) !== Number(piCid)) continue;
+
+          if (alertType && alertType.isTest) {
+            const prefs = await this._getPrefs(userCid);
+            if (!prefs || prefs.testAlerts !== true) continue;
+          }
+
+          subscriptions.push({
+            userCid,
+            piCid: Number(piCid),
+            piUsername: item.username || piUsername,
+            watchlistId: watchlist.id,
+            watchlistName: watchlist.name || 'Unnamed Watchlist',
+            alertConfig: item.alertConfig || {},
+            useDynamic: item.useDynamic || {},
+            dynamicConfig: item.dynamicConfig || {}
+          });
+          break;
+        }
+      }
+    }
+
+    await this._appendDevOverrides(subscriptions, piCid, piUsername, alertType);
+    return subscriptions;
+  }
+
+  async _getPrefs(userCid) {
+    try {
+      return await manageNotificationPreferences(this.db, userCid, 'get');
+    } catch (e) {
+      this.logger?.log('WARN', `[UserConfigRepo] Prefs read failed for ${userCid}: ${e.message}`);
+      return null;
+    }
+  }
+
+  async _resolvePiUsername(piCid) {
+    try {
+      const data = await fetchPopularInvestorMasterList(this.db, String(piCid));
+      if (data && data.username) return data.username;
+    } catch (e) {}
+    return `PI-${piCid}`;
+  }
+
+  async _appendDevOverrides(subscriptions, piCid, piUsername, alertType) {
+    try {
+      const devOverridesSnap = await this.db.collection(this.config.collections.devOverrides).get();
+      for (const doc of devOverridesSnap.docs) {
+        const userCid = Number(doc.id);
+        const isDev = await isDeveloper(this.db, String(userCid));
+        if (!isDev) continue;
+
+        const data = doc.data();
+        if (data.enabled !== true || data.pretendSubscribedToAllAlerts !== true) continue;
+
+        subscriptions.push({
+          userCid,
+          piCid: Number(piCid),
+          piUsername,
+          watchlistId: 'dev-override-all-alerts',
+          watchlistName: 'Dev Override - All Alerts',
+          alertConfig: { [alertType.configKey]: true },
+          useDynamic: {},
+          dynamicConfig: {}
+        });
+      }
+    } catch (e) {
+      this.logger?.log('WARN', `[UserConfigRepo] Dev override check failed: ${e.message}`);
+    }
+  }
+}
+
+module.exports = { UserConfigRepo };

package/functions/alert-system-v3/config/defaults.js

@@ -0,0 +1,14 @@
+'use strict';
+
+module.exports = {
+  topics: {
+    raw: process.env.ALERT_RAW_TOPIC || 'alert-raw-topic',
+    notify: process.env.ALERT_NOTIFY_TOPIC || 'alert-notify-topic',
+    history: process.env.ALERT_HISTORY_TOPIC || 'alert-history-topic'
+  },
+  collections: {
+    watchlistMembership: 'WatchlistMembershipData',
+    signedInUsers: 'SignedInUsers',
+    devOverrides: 'dev_overrides'
+  }
+};

package/functions/alert-system-v3/core/AlertContext.js

@@ -0,0 +1,34 @@
+'use strict';
+
+const { PubSubUtils } = require('../../core/utils/pubsub_utils');
+const { MembershipRepo } = require('../adapters/MembershipRepo');
+const { UserConfigRepo } = require('../adapters/UserConfigRepo');
+const { NotificationBus } = require('../adapters/NotificationBus');
+const defaults = require('../config/defaults');
+
+function createAlertContext(dependencies, overrideConfig = {}) {
+  const config = {
+    ...defaults,
+    ...overrideConfig,
+    topics: { ...defaults.topics, ...(overrideConfig.topics || {}) },
+    collections: { ...defaults.collections, ...(overrideConfig.collections || {}) }
+  };
+
+  const pubsubUtils = new PubSubUtils(dependencies);
+  const membershipRepo = new MembershipRepo(dependencies, config);
+  const userConfigRepo = new UserConfigRepo(dependencies, config);
+  const notificationBus = new NotificationBus({ ...dependencies, pubsubUtils }, config);
+
+  return {
+    ...dependencies,
+    config,
+    pubsubUtils,
+    membershipRepo,
+    userConfigRepo,
+    notificationBus
+  };
+}
+
+module.exports = {
+  createAlertContext
+};

package/functions/alert-system-v3/core/AlertLogic.js

@@ -0,0 +1,39 @@
+'use strict';
+
+const { evaluateDynamicConditions } = require('../../alert-system/helpers/dynamic_evaluator');
+
+function evaluateAlertForSubscription({ alertType, piResult, subscription, isDeveloper, logger }) {
+  if (!alertType || !subscription) {
+    return { shouldNotify: false, reason: 'missing-input', mode: 'invalid' };
+  }
+
+  const configKey = alertType.configKey;
+  const isEnabled = !!(subscription.alertConfig && configKey && subscription.alertConfig[configKey] === true);
+  if (!isEnabled) {
+    return { shouldNotify: false, reason: 'disabled', mode: 'static' };
+  }
+
+  const useDynamic = !!(subscription.useDynamic && configKey && subscription.useDynamic[configKey] === true);
+  const dynamicConfig = subscription.dynamicConfig && configKey ? subscription.dynamicConfig[configKey] : null;
+
+  const evaluation = evaluateDynamicConditions(
+    alertType,
+    piResult || {},
+    dynamicConfig || {},
+    useDynamic,
+    !!isDeveloper,
+    logger
+  );
+
+  return {
+    shouldNotify: evaluation.passes === true,
+    reason: evaluation.reason,
+    mode: evaluation.mode || (useDynamic ? 'dynamic' : 'static'),
+    effectiveConfig: evaluation.effectiveConfig || null,
+    developerBypass: evaluation.developerBypass === true
+  };
+}
+
+module.exports = {
+  evaluateAlertForSubscription
+};

package/functions/alert-system-v3/core/ComputationResults.js

@@ -0,0 +1,99 @@
+'use strict';
+
+const zlib = require('zlib');
+const { Storage } = require('@google-cloud/storage');
+
+const storage = new Storage();
+
+function tryDecompress(data) {
+  if (data && data._compressed === true && data.payload) {
+    try {
+      let buffer;
+      if (Buffer.isBuffer(data.payload)) {
+        buffer = data.payload;
+      } else if (typeof data.payload === 'string') {
+        buffer = Buffer.from(data.payload, 'base64');
+      } else {
+        buffer = Buffer.from(data.payload);
+      }
+      const decompressed = zlib.gunzipSync(buffer);
+      const jsonString = decompressed.toString('utf8');
+      const parsed = JSON.parse(jsonString);
+      return typeof parsed === 'string' ? JSON.parse(parsed) : parsed;
+    } catch (e) {
+      return {};
+    }
+  }
+  return data;
+}
+
+function readComputationResults(docData) {
+  const decompressed = tryDecompress(docData);
+  if (decompressed && typeof decompressed === 'object') {
+    if (Array.isArray(decompressed.cids)) {
+      const perUserData = {};
+      for (const key of Object.keys(decompressed)) {
+        if (key !== 'cids' && key !== 'metadata' && /^\d+$/.test(key)) {
+          perUserData[Number(key)] = decompressed[key];
+        }
+      }
+      return {
+        cids: decompressed.cids,
+        perUserData,
+        metadata: decompressed.metadata || {}
+      };
+    }
+    const cids = Object.keys(decompressed)
+      .filter(k => /^\d+$/.test(k))
+      .map(k => Number(k));
+    return {
+      cids,
+      perUserData: cids.reduce((acc, cid) => {
+        const val = decompressed[String(cid)];
+        if (val) acc[cid] = val;
+        return acc;
+      }, {}),
+      metadata: decompressed.metadata || {}
+    };
+  }
+  return { cids: [], perUserData: {}, metadata: {} };
+}
+
+async function readComputationResultsWithShards(db, docData, docRef, logger) {
+  try {
+    if (docData.gcsUri || (docData._gcs && docData.gcsBucket && docData.gcsPath)) {
+      const bucketName = docData.gcsBucket || docData.gcsUri.split('/')[2];
+      const fileName = docData.gcsPath || docData.gcsUri.split('/').slice(3).join('/');
+      const [fileContent] = await storage.bucket(bucketName).file(fileName).download();
+      let parsed;
+      try {
+        parsed = JSON.parse(zlib.gunzipSync(fileContent).toString('utf8'));
+      } catch (e) {
+        parsed = JSON.parse(fileContent.toString('utf8'));
+      }
+      return readComputationResults(parsed);
+    }
+
+    if (docData._sharded === true && docData._shardCount) {
+      const shardsCol = docRef.collection('_shards');
+      const shardsSnapshot = await shardsCol.get();
+      if (!shardsSnapshot.empty) {
+        const merged = {};
+        for (const shardDoc of shardsSnapshot.docs) {
+          const shardData = tryDecompress(shardDoc.data());
+          Object.assign(merged, shardData);
+        }
+        return readComputationResults(merged);
+      }
+    }
+
+    return readComputationResults(docData);
+  } catch (error) {
+    logger?.log('ERROR', `[AlertSystemV3] Failed reading results: ${error.message}`);
+    return { cids: [], perUserData: {}, metadata: {} };
+  }
+}
+
+module.exports = {
+  readComputationResultsWithShards
+};

package/functions/alert-system-v3/handlers/history.js

@@ -0,0 +1,40 @@
+'use strict';
+
+const { createAlertContext } = require('../core/AlertContext');
+// CHANGE 1: Import the whole module object
+const bqUtils = require('../../core/utils/bigquery_utils'); 
+
+async function handleAlertHistory(message, context, config, dependencies) {
+  const ctx = createAlertContext(dependencies, config);
+  const { logger } = ctx;
+
+  try {
+    const payload = JSON.parse(Buffer.from(message.data, 'base64').toString());
+    const datasetId = process.env.BIGQUERY_DATASET_ID || 'bulltrackers_data';
+
+    // CHANGE 2: Call functions off the object
+    await bqUtils.ensurePIAlertHistoryTable(logger);
+
+    const row = {
+      date: payload.date,
+      pi_id: Number(payload.piId),
+      alert_type: payload.alertType,
+      triggered: true,
+      trigger_count: payload.triggerCount || 0,
+      triggered_for: payload.triggeredFor || [],
+      metadata: payload.metadata && typeof payload.metadata === 'object' ? payload.metadata : {},
+      last_triggered: payload.lastTriggered || new Date().toISOString(),
+      last_updated: payload.lastUpdated || new Date().toISOString()
+    };
+
+    // CHANGE 3: Call functions off the object
+    await bqUtils.insertRowsWithMerge(datasetId, 'pi_alert_history', [row], ['date', 'pi_id', 'alert_type'], logger);
+    
+    logger?.log('INFO', `[AlertV3/History] Synced ${payload.alertType} for PI ${payload.piId}`);
+  } catch (error) {
+    logger?.log('ERROR', `[AlertV3/History] Failed: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = { handleAlertHistory };

package/functions/alert-system-v3/handlers/ingest.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const { createAlertContext } = require('../core/AlertContext');
+const { loadAlertTypesFromManifest, isAlertComputation } = require('../../alert-system/helpers/alert_manifest_loader');
+
+let cachedAlertTypes = null;
+
+async function handleComputationResultWrite(change, context, config, dependencies) {
+  const ctx = createAlertContext(dependencies, config);
+  const { logger } = ctx;
+  const { date, computationName, entityId } = context.params || {};
+
+  try {
+    if (!change.after.exists) return;
+    if (!cachedAlertTypes) cachedAlertTypes = await loadAlertTypesFromManifest(logger);
+
+    if (!isAlertComputation(cachedAlertTypes, computationName)) return;
+
+    const payload = {
+      date,
+      computationName,
+      entityId: entityId || null,
+      documentPath: change.after.ref.path,
+      timestamp: Date.now(),
+      traceId: context.eventId
+    };
+
+    await ctx.notificationBus.publishRawEvent(payload);
+    logger?.log('INFO', `[AlertV3/Ingest] Queued ${computationName} for ${date}`);
+  } catch (error) {
+    logger?.log('ERROR', `[AlertV3/Ingest] Failed: ${error.message}`);
+  }
+}
+
+module.exports = { handleComputationResultWrite };

package/functions/alert-system-v3/handlers/notifier.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const { createAlertContext } = require('../core/AlertContext');
+const { FieldValue } = require('@google-cloud/firestore');
+// CHANGE 1: Import the whole object to allow Stubbing
+const fcmUtils = require('../../core/utils/fcm_utils'); 
+
+async function handleAlertNotification(message, context, config, dependencies) {
+  const ctx = createAlertContext(dependencies, config);
+  const { db, logger } = ctx;
+
+  try {
+    const payload = JSON.parse(Buffer.from(message.data, 'base64').toString());
+
+    const alertId = `alert_${payload.computationDate}_${payload.alertTypeId}_${payload.piCid}_${payload.userCid}_${payload.watchlistId}`;
+
+    const alertData = {
+      alertId,
+      piCid: Number(payload.piCid),
+      piUsername: payload.piUsername || `PI-${payload.piCid}`,
+      alertType: payload.alertTypeId,
+      alertTypeName: payload.alertTypeName,
+      message: payload.message,
+      severity: payload.severity || 'medium',
+      watchlistId: payload.watchlistId,
+      watchlistName: payload.watchlistName,
+      read: false,
+      createdAt: FieldValue.serverTimestamp(),
+      computationDate: payload.computationDate,
+      computationName: payload.computationName,
+      ...(payload.metadata || {})
+    };
+
+    // 1. Write to Inbox (Firestore)
+    await db.collection(ctx.config.collections.signedInUsers)
+      .doc(String(payload.userCid))
+      .collection('alerts')
+      .doc(alertId)
+      .set(alertData);
+
+    try {
+      // CHANGE 2: Call the function off the object
+      await fcmUtils.sendAlertPushNotification(db, payload.userCid, alertData, logger);
+    } catch (e) {
+      logger?.log('WARN', `[AlertV3/Notifier] FCM failed for ${payload.userCid}: ${e.message}`);
+    }
+  } catch (error) {
+    logger?.log('ERROR', `[AlertV3/Notifier] Failed: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = { handleAlertNotification };

package/functions/alert-system-v3/handlers/router.js

@@ -0,0 +1,118 @@
+'use strict';
+
+const { createAlertContext } = require('../core/AlertContext');
+// Use object references to allow Sinon stubbing
+const computationResults = require('../core/ComputationResults');
+const alertLogic = require('../core/AlertLogic');
+// Import legacy helpers as objects
+const manifestLoader = require('../../alert-system/helpers/alert_manifest_loader');
+
+let cachedAlertTypes = null;
+
+async function handleRawAlert(message, context, config, dependencies) {
+  const ctx = createAlertContext(dependencies, config);
+  const { db, logger } = ctx;
+
+  try {
+    const payload = JSON.parse(Buffer.from(message.data, 'base64').toString());
+    const { date, computationName, documentPath } = payload;
+
+    // Call through the object reference
+    if (!cachedAlertTypes) {
+      cachedAlertTypes = await manifestLoader.loadAlertTypesFromManifest(logger);
+    }
+    
+    const alertType = manifestLoader.getAlertTypeByComputation(cachedAlertTypes, computationName);
+    
+    if (!alertType) {
+      logger?.log('WARN', `[AlertV3/Router] Unknown computation ${computationName}`);
+      return;
+    }
+
+    const docRef = db.doc(documentPath);
+    const snapshot = await docRef.get();
+    if (!snapshot.exists) return;
+
+    // Reference the computationResults object
+    const results = await computationResults.readComputationResultsWithShards(db, snapshot.data(), docRef, logger);
+    const cids = Array.isArray(results.cids) ? results.cids : [];
+
+    const notifications = [];
+    const historyEvents = [];
+
+    for (const piCid of cids) {
+      const piResult = (results.perUserData && results.perUserData[piCid]) || results.metadata || {};
+
+      const userCids = await ctx.membershipRepo.getUserCidsForPi(date, piCid);
+      if (!userCids.length) continue;
+
+      const subscriptions = await ctx.userConfigRepo.getSubscriptionsForPi({ piCid, userCids, alertType });
+      const triggeredFor = [];
+
+      for (const subscription of subscriptions) {
+        const isDeveloper = false;
+        // Call through the alertLogic object reference
+        const evaluation = alertLogic.evaluateAlertForSubscription({
+          alertType,
+          piResult,
+          subscription,
+          isDeveloper,
+          logger
+        });
+
+        if (!evaluation.shouldNotify) continue;
+
+        const piUsername = subscription.piUsername || piResult.username || `PI-${piCid}`;
+        const messageText = manifestLoader.generateAlertMessage(alertType, piUsername, piResult);
+
+        notifications.push({
+          userCid: subscription.userCid,
+          piCid: Number(piCid),
+          piUsername,
+          alertTypeId: alertType.id,
+          alertTypeName: alertType.name,
+          computationName: alertType.computationName,
+          computationDate: date,
+          severity: alertType.severity || 'medium',
+          watchlistId: subscription.watchlistId,
+          watchlistName: subscription.watchlistName,
+          message: messageText,
+          metadata: piResult,
+          evaluation
+        });
+
+        triggeredFor.push(String(subscription.userCid));
+      }
+
+      if (triggeredFor.length) {
+        historyEvents.push({
+          date,
+          piId: Number(piCid),
+          alertType: alertType.computationName || alertType.id,
+          computationName: alertType.computationName,
+          triggered: true,
+          triggerCount: triggeredFor.length,
+          triggeredFor,
+          metadata: piResult,
+          lastTriggered: new Date().toISOString(),
+          lastUpdated: new Date().toISOString()
+        });
+      }
+    }
+
+    if (notifications.length) {
+      await ctx.notificationBus.publishNotifications(notifications);
+    }
+
+    if (historyEvents.length) {
+      await ctx.notificationBus.publishHistoryEvents(historyEvents);
+    }
+
+    logger?.log('INFO', `[AlertV3/Router] Notifications: ${notifications.length}, History: ${historyEvents.length}`);
+  } catch (error) {
+    logger?.log('ERROR', `[AlertV3/Router] Failed: ${error.message}`);
+    throw error;
+  }
+}
+
+module.exports = { handleRawAlert };

package/functions/alert-system-v3/index.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const { handleComputationResultWrite } = require('./handlers/ingest');
+const { handleRawAlert } = require('./handlers/router');
+const { handleAlertNotification } = require('./handlers/notifier');
+const { handleAlertHistory } = require('./handlers/history');
+
+module.exports = {
+  handleComputationResultWrite,
+  handleRawAlert,
+  handleAlertNotification,
+  handleAlertHistory
+};