bulltrackers-module 1.0.502 → 1.0.504

package/functions/generic-api/user-api/helpers/collection_helpers.js

@@ -51,8 +51,8 @@ function extractCollectionName(path) {
  * @param {Firestore} db - Firestore instance
  * @param {string} newPath - New collection path
  * @param {string} legacyPath - Legacy collection path
- * @param {object} options - Options for reading
- * @param {boolean} options.isCollection - If true, reads as collection; if false, reads as document
+ * @param {object} [options={}] - Options for reading
+ * @param {boolean} [options.isCollection=false] - If true, reads as collection; if false, reads as document
  * @returns {Promise<object|null>} - Document data or null if not found
  */
 async function readWithFallback(db, newPath, legacyPath, options = {}) {
@@ -101,9 +101,9 @@ async function readWithFallback(db, newPath, legacyPath, options = {}) {
  * @param {string} newPath - New collection path
  * @param {string} legacyPath - Legacy collection path
  * @param {object} data - Data to write
- * @param {object} options - Write options
- * @param {boolean} options.isCollection - If true, writes as collection; if false, writes as document
- * @param {boolean} options.merge - If true, merges data instead of overwriting
+ * @param {object} [options={}] - Write options
+ * @param {boolean} [options.isCollection=false] - If true, writes as collection; if false, writes as document
+ * @param {boolean} [options.merge=false] - If true, merges data instead of overwriting
  * @returns {Promise<void>}
  */
 async function writeDual(db, newPath, legacyPath, data, options = {}) {

package/functions/generic-api/user-api/helpers/data_helpers.js

@@ -72,10 +72,41 @@ function tryDecompress(data) {
  * Helper function to find the latest available date for signed-in user portfolio data
  * Searches backwards from today up to 30 days
  */
-async function findLatestPortfolioDate(db, signedInUsersCollection, userCid, maxDaysBack = 30) {
+async function findLatestPortfolioDate(db, signedInUsersCollection, userCid, maxDaysBack = 30, collectionRegistry = null) {
     const CANARY_BLOCK_ID = '19M';
     const today = new Date();
     
+    // Try new structure first if collectionRegistry is available
+    if (collectionRegistry) {
+        try {
+            const { getRootDataPortfolioPath } = require('./collection_helpers');
+            
+            for (let i = 0; i < maxDaysBack; i++) {
+                const checkDate = new Date(today);
+                checkDate.setDate(checkDate.getDate() - i);
+                const dateStr = checkDate.toISOString().split('T')[0];
+                
+                try {
+                    const rootPath = getRootDataPortfolioPath(collectionRegistry, dateStr, userCid);
+                    const rootDoc = await db.doc(rootPath).get();
+                    
+                    if (rootDoc.exists) {
+                        const data = rootDoc.data();
+                        if (data && (data.AggregatedPositions || data.AggregatedMirrors)) {
+                            return dateStr; // Found data in new structure
+                        }
+                    }
+                } catch (error) {
+                    // Continue to next date if error
+                    continue;
+                }
+            }
+        } catch (error) {
+            // Fall through to legacy check
+        }
+    }
+    
+    // Fallback to legacy structure
     for (let i = 0; i < maxDaysBack; i++) {
         const checkDate = new Date(today);
         checkDate.setDate(checkDate.getDate() - i);
@@ -637,9 +668,9 @@ async function getUserPortfolio(req, res, dependencies, config) {
         // 1. Try user-centric latest snapshot
         if (collectionRegistry) {
             try {
-                const { getUserPortfolioPath, extractCollectionName } = require('./collection_helpers');
+                const { getUserPortfolioPath, extractCollectionName: extractCollectionNameHelper } = require('./collection_helpers');
                 const latestPath = getUserPortfolioPath(collectionRegistry, effectiveCid);
-                const collectionName = extractCollectionName(latestPath);
+                const collectionName = extractCollectionNameHelper(latestPath);
                 
                 const latestDoc = await db.collection(collectionName)
                     .doc(effectiveCidStr)
@@ -665,7 +696,7 @@ async function getUserPortfolio(req, res, dependencies, config) {
         // 2. Try root data structure (date-based)
         if (!portfolioData && collectionRegistry) {
             try {
-                const { getRootDataPortfolioPath, extractCollectionName } = require('./collection_helpers');
+                const { getRootDataPortfolioPath } = require('./collection_helpers');
                 const rootPath = getRootDataPortfolioPath(collectionRegistry, dataDate, effectiveCid);
                 
                 // Path is: SignedInUserPortfolioData/{date}/{cid}
@@ -2112,9 +2143,11 @@ async function trackProfileView(req, res, dependencies, config) {
         }
         
         // Fallback to legacy check
+        let viewDocId = `${piCid}_${today}`;
+        let viewRef = null;
+        
         if (existingUniqueViewers.length === 0) {
-            const viewDocId = `${piCid}_${today}`;
-            const viewRef = db.collection(profileViewsCollection).doc(viewDocId);
+            viewRef = db.collection(profileViewsCollection).doc(viewDocId);
             const existingDoc = await viewRef.get();
             if (existingDoc.exists) {
                 existingData = existingDoc.data();
@@ -2136,9 +2169,6 @@ async function trackProfileView(req, res, dependencies, config) {
         };
         
         // Write to both new and legacy structures
-        const { getCollectionPath, writeDual } = require('./collection_helpers');
-        const { collectionRegistry } = dependencies;
-        
         if (collectionRegistry) {
             const newPath = getCollectionPath(collectionRegistry, 'popularInvestors', 'profileViews', {
                 piCid: String(piCid)
@@ -2146,8 +2176,11 @@ async function trackProfileView(req, res, dependencies, config) {
             
             const legacyPath = `${profileViewsCollection}/${viewDocId}`;
             
-            await writeDual(db, newPath, legacyPath, viewData, { merge: true });
+            await writeDual(db, newPath, legacyPath, viewData, { isCollection: false, merge: true });
         } else {
+            if (!viewRef) {
+                viewRef = db.collection(profileViewsCollection).doc(viewDocId);
+            }
             await viewRef.set(viewData, { merge: true });
         }
         

package/functions/generic-api/user-api/helpers/on_demand_fetch_helpers.js

@@ -112,7 +112,7 @@ async function requestPiFetch(req, res, dependencies, config) {
             
             const legacyPath = `pi_fetch_requests/${piCidNum}/requests/${requestId}`;
             
-            await writeDual(db, newPath, legacyPath, requestData);
+            await writeDual(db, newPath, legacyPath, requestData, { isCollection: false, merge: false });
         } else {
             // Fallback to legacy only
             const requestRef = db.collection('pi_fetch_requests')
@@ -139,7 +139,7 @@ async function requestPiFetch(req, res, dependencies, config) {
             
             const legacyUserPath = `pi_fetch_requests/${piCidNum}/user_requests/${requestUserCid}`;
             
-            await writeDual(db, newUserPath, legacyUserPath, userRequestData, { merge: true });
+            await writeDual(db, newUserPath, legacyUserPath, userRequestData, { isCollection: false, merge: true });
         } else {
             const userRequestRef = db.collection('pi_fetch_requests')
                 .doc(String(piCidNum))
@@ -165,7 +165,7 @@ async function requestPiFetch(req, res, dependencies, config) {
             
             const legacyGlobalPath = `pi_fetch_requests/${piCidNum}/global/latest`;
             
-            await writeDual(db, newGlobalPath, legacyGlobalPath, globalData, { merge: true });
+            await writeDual(db, newGlobalPath, legacyGlobalPath, globalData, { isCollection: false, merge: true });
         } else {
             const globalRef = db.collection('pi_fetch_requests')
                 .doc(String(piCidNum))
@@ -287,7 +287,6 @@ async function getPiFetchStatus(req, res, dependencies, config) {
             
             const doc = await docRef.get();
             if (doc.exists) {
-                const { tryDecompress } = require('./data_helpers');
                 const data = tryDecompress(doc.data());
                 
                 if (data && data[String(piCidNum)]) {

package/functions/generic-api/user-api/helpers/review_helpers.js

@@ -143,7 +143,7 @@ async function hasUserCopied(db, userCid, piCid, config) {
                                         // If key exists, merge arrays or objects
                                         if (Array.isArray(mergedData[key]) && Array.isArray(value)) {
                                             mergedData[key] = [...mergedData[key], ...value];
-                                        } else if (typeof mergedData[key] === 'object' && typeof value === 'object') {
+                                        } else if (typeof mergedData[key] === 'object' && typeof value === 'object' && mergedData[key] !== null && value !== null) {
                                             mergedData[key] = { ...mergedData[key], ...value };
                                         } else {
                                             mergedData[key] = value;
@@ -374,7 +374,7 @@ async function submitReview(req, res, dependencies, config) {
             
             const legacyPath = `${reviewsCollection}/${reviewId}`;
             
-            await writeDual(db, newPath, legacyPath, reviewData, { merge: true });
+            await writeDual(db, newPath, legacyPath, reviewData, { isCollection: false, merge: true });
         } else {
             await db.collection(reviewsCollection).doc(reviewId).set(reviewData, { merge: true });
         }
@@ -541,7 +541,7 @@ async function getUserReview(req, res, dependencies, config) {
         
         const data = reviewData;
         const review = {
-            id: reviewDoc.id,
+            id: reviewId, // Use reviewId which is already defined
             rating: data.rating,
             comment: data.comment || "",
             isAnonymous: data.isAnonymous || false,

package/functions/generic-api/user-api/helpers/subscription_helpers.js

@@ -80,7 +80,7 @@ async function subscribeToAlerts(req, res, dependencies, config) {
             
             const legacyPath = `watchlist_subscriptions/${userCid}/alerts/${piCid}`;
             
-            await writeDual(db, newPath, legacyPath, subscriptionData, { merge: true });
+            await writeDual(db, newPath, legacyPath, subscriptionData, { isCollection: false, merge: true });
         } else {
             // Global subscription: signedInUsers/{cid}/subscriptions/{piCid}
             if (collectionRegistry) {
@@ -90,7 +90,7 @@ async function subscribeToAlerts(req, res, dependencies, config) {
                 
                 const legacyPath = `watchlist_subscriptions/${userCid}/alerts/${piCid}`;
                 
-                await writeDual(db, newPath, legacyPath, subscriptionData, { merge: true });
+                await writeDual(db, newPath, legacyPath, subscriptionData, { isCollection: false, merge: true });
             } else {
                 // Fallback to legacy only
                 const subscriptionsCollection = config.watchlistSubscriptionsCollection || 'watchlist_subscriptions';
@@ -183,7 +183,7 @@ async function updateSubscription(req, res, dependencies, config) {
         // Update both structures if using new path, otherwise just legacy
         if (newPath && collectionRegistry) {
             const updatedData = { ...subscriptionData, ...updates };
-            await writeDual(db, newPath, legacyPath, updatedData, { merge: true });
+            await writeDual(db, newPath, legacyPath, updatedData, { isCollection: false, merge: true });
         } else if (subscriptionRef) {
             await subscriptionRef.update(updates);
         }
@@ -242,7 +242,6 @@ async function unsubscribeFromAlerts(req, res, dependencies, config) {
         
         // Also check per-watchlist subscriptions (need to search all watchlists)
         if (collectionRegistry && !found) {
-            const { getCollectionPath } = require('./collection_helpers');
             const watchlistsPath = getCollectionPath(collectionRegistry, 'signedInUsers', 'watchlists', {
                 cid: String(userCid)
             });

package/functions/generic-api/user-api/helpers/user_sync_helpers.js

@@ -155,8 +155,8 @@ async function requestUserSync(req, res, dependencies, config) {
         };
         
         // Write to both new and legacy locations during migration
-        await writeDual(db, newRequestPath, legacyRequestPath, requestData);
-        await writeDual(db, newStatusPath, legacyStatusPath, statusData, { merge: true });
+        await writeDual(db, newRequestPath, legacyRequestPath, requestData, { isCollection: false, merge: false });
+        await writeDual(db, newStatusPath, legacyStatusPath, statusData, { isCollection: false, merge: true });
         
         // Also update the request ref for later updates (use new path)
         const requestRef = db.doc(newRequestPath);
@@ -415,6 +415,10 @@ async function getUserSyncStatus(req, res, dependencies, config) {
                 if (referenceTime && (now - referenceTime) > STALE_THRESHOLD_MS) {
                     // Before marking as stale, do one final check for computation results
                     // Sometimes computation completes but status wasn't updated
+                    const insightsCollection = config.unifiedInsightsCollection || 'unified_insights';
+                    const resultsSub = config.resultsSubcollection || 'results';
+                    const compsSub = config.computationsSubcollection || 'computations';
+                    
                     const finalCheck = await checkComputationResults(db, targetCidNum, userType, insightsCollection, resultsSub, compsSub, logger);
                     if (!finalCheck) {
                         isStale = true;

package/functions/generic-api/user-api/helpers/verification_helpers.js

@@ -181,14 +181,14 @@ async function finalizeVerification(req, res, dependencies, config) {
         
         if (newUserPath && collectionRegistry) {
             // Write to both during migration
-            await writeDual(db, newUserPath, legacyUserPath, userData, { merge: true });
+            await writeDual(db, newUserPath, legacyUserPath, userData, { isCollection: false, merge: true });
         } else {
             // Fallback to legacy only
             await db.collection(signedInUsersCollection).doc(String(realCID)).set(userData, { merge: true });
         }
         
         // Also store verification data in user-centric path
-        const verificationData = {
+        const newVerificationData = {
             status: 'VERIFIED',
             verifiedAt: FieldValue.serverTimestamp(),
             cid: realCID,
@@ -202,7 +202,7 @@ async function finalizeVerification(req, res, dependencies, config) {
             : null;
         
         if (newVerificationPath && collectionRegistry) {
-            await db.doc(newVerificationPath).set(verificationData, { merge: true });
+            await db.doc(newVerificationPath).set(newVerificationData, { merge: true });
         }
 
         // 3. Trigger Downstream Systems via Pub/Sub

package/functions/generic-api/user-api/helpers/watchlist_helpers.js

@@ -213,7 +213,7 @@ async function createWatchlist(req, res, dependencies, config) {
             
             const legacyPath = `${config.watchlistsCollection || 'watchlists'}/${userCid}/lists/${watchlistId}`;
             
-            await writeDual(db, newWatchlistPath, legacyPath, watchlistData);
+            await writeDual(db, newWatchlistPath, legacyPath, watchlistData, { isCollection: false, merge: false });
         } else {
             // Fallback to legacy only
             const watchlistsCollection = config.watchlistsCollection || 'watchlists';
@@ -364,7 +364,7 @@ async function updateWatchlist(req, res, dependencies, config) {
         // Update both structures if using new path
         if (newPath && collectionRegistry) {
             const updatedData = { ...existingData, ...updates };
-            await writeDual(db, newPath, legacyPath, updatedData, { merge: true });
+            await writeDual(db, newPath, legacyPath, updatedData, { isCollection: false, merge: true });
         } else {
             await watchlistRef.update(updates);
         }
@@ -406,6 +406,7 @@ async function deleteWatchlist(req, res, dependencies, config) {
         
         // Find and delete from both structures
         let found = false;
+        let watchlistData = null; // Store watchlist data for public watchlist check
         
         if (collectionRegistry) {
             try {
@@ -420,7 +421,7 @@ async function deleteWatchlist(req, res, dependencies, config) {
                 
                 const watchlistDoc = await watchlistRef.get();
                 if (watchlistDoc.exists) {
-                    const watchlistData = watchlistDoc.data();
+                    watchlistData = watchlistDoc.data();
                     // Verify ownership
                     if (watchlistData.createdBy !== Number(userCid)) {
                         return res.status(403).json({ error: "You can only delete your own watchlists" });
@@ -434,21 +435,23 @@ async function deleteWatchlist(req, res, dependencies, config) {
         }
         
         // Also delete from legacy
-        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
-        const watchlistRef = db.collection(watchlistsCollection)
-            .doc(String(userCid))
-            .collection('lists')
-            .doc(id);
-        
-        const watchlistDoc = await watchlistRef.get();
-        if (watchlistDoc.exists) {
-            const watchlistData = watchlistDoc.data();
-            // Verify ownership
-            if (watchlistData.createdBy !== Number(userCid)) {
-                return res.status(403).json({ error: "You can only delete your own watchlists" });
+        if (!found || !watchlistData) {
+            const watchlistsCollection = config.watchlistsCollection || 'watchlists';
+            const watchlistRef = db.collection(watchlistsCollection)
+                .doc(String(userCid))
+                .collection('lists')
+                .doc(id);
+            
+            const watchlistDoc = await watchlistRef.get();
+            if (watchlistDoc.exists) {
+                watchlistData = watchlistDoc.data();
+                // Verify ownership
+                if (watchlistData.createdBy !== Number(userCid)) {
+                    return res.status(403).json({ error: "You can only delete your own watchlists" });
+                }
+                await watchlistRef.delete();
+                found = true;
             }
-            await watchlistRef.delete();
-            found = true;
         }
         
         if (!found) {
@@ -456,7 +459,7 @@ async function deleteWatchlist(req, res, dependencies, config) {
         }
         
         // Remove from public watchlists if it was public
-        if (watchlistData.visibility === 'public') {
+        if (watchlistData && watchlistData.visibility === 'public') {
             const publicRef = db.collection('public_watchlists').doc(id);
             await publicRef.delete();
         }

package/package.json

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