bulltrackers-module 1.0.509 → 1.0.511

package/functions/generic-api/user-api/helpers/core/path_resolution_helpers.js

@@ -31,7 +31,7 @@ function getRegistryFunctions(options = {}) {
         return {
             getCollectionPath: options.collectionRegistry.getCollectionPath,
             resolvePath: options.collectionRegistry.resolvePath || resolvePath,
-            getCollectionMetadata: options.collectionRegistry.getCollectionMetadata || options.collectionRegistry.getCollectionMetadata
+            getCollectionMetadata: options.collectionRegistry.getCollectionMetadata
         };
     }
     
@@ -254,6 +254,7 @@ async function readWithMigration(db, category, subcategory, params, options = {}
     if (newPath) {
         try {
             if (isCollection) {
+                // Collection path must have odd number of segments
                 const collectionRef = db.collection(newPath);
                 const snapshot = await collectionRef.get();
                 if (!snapshot.empty) {
@@ -261,9 +262,21 @@ async function readWithMigration(db, category, subcategory, params, options = {}
                     return { snapshot, source: 'new', path: newPath };
                 }
             } else {
-                const docRef = documentId 
-                    ? db.collection(newPath).doc(documentId)
-                    : db.doc(newPath);
+                // Document path: if newPath has even segments, it's already a document path
+                // If documentId is provided, newPath should be collection path (odd segments)
+                let docRef;
+                if (documentId) {
+                    // newPath should be collection (odd segments), add documentId
+                    const pathSegments = newPath.split('/');
+                    if (pathSegments.length % 2 === 0) {
+                        // Even segments = document path, can't add documentId
+                        throw new Error(`Path ${newPath} is a document path but documentId was provided`);
+                    }
+                    docRef = db.collection(newPath).doc(documentId);
+                } else {
+                    // No documentId, newPath should be full document path (even segments)
+                    docRef = db.doc(newPath);
+                }
                 const doc = await docRef.get();
                 if (doc.exists) {
                     if (logger) logger.log('INFO', `[readWithMigration] Found data in new path: ${docRef.path}`);
@@ -471,6 +484,11 @@ async function writeWithMigration(db, category, subcategory, params, data, optio
             if (!documentId) {
                 throw new Error('Collection writes require documentId');
             }
+            // Collection path must have odd number of segments
+            const pathSegments = newPath.split('/');
+            if (pathSegments.length % 2 === 0) {
+                throw new Error(`Path ${newPath} is a document path but isCollection=true was specified`);
+            }
             const newRef = db.collection(newPath).doc(documentId);
             if (merge) {
                 batch.set(newRef, data, { merge: true });
@@ -478,9 +496,18 @@ async function writeWithMigration(db, category, subcategory, params, data, optio
                 batch.set(newRef, data);
             }
         } else {
-            const newRef = documentId 
-                ? db.collection(newPath).doc(documentId)
-                : db.doc(newPath);
+            // Document path: if documentId provided, newPath should be collection (odd segments)
+            // If no documentId, newPath should be full document path (even segments)
+            let newRef;
+            if (documentId) {
+                const pathSegments = newPath.split('/');
+                if (pathSegments.length % 2 === 0) {
+                    throw new Error(`Path ${newPath} is a document path but documentId was provided`);
+                }
+                newRef = db.collection(newPath).doc(documentId);
+            } else {
+                newRef = db.doc(newPath);
+            }
             if (merge) {
                 batch.set(newRef, data, { merge: true });
             } else {

package/functions/generic-api/user-api/helpers/core/user_status_helpers.js

@@ -18,7 +18,7 @@ const { findLatestRankingsDate } = require('./data_lookup_helpers');
 async function checkIfUserIsPI(db, userCid, config, logger = null) {
     try {
         // Check dev override first (for developer accounts)
-        const { getDevOverride } = require('../dev_helpers');
+        const { getDevOverride } = require('../dev/dev_helpers');
         const devOverride = await getDevOverride(db, userCid, config, logger);
         
         if (devOverride && devOverride.enabled && devOverride.pretendToBePI) {

package/functions/generic-api/user-api/helpers/search/pi_request_helpers.js

@@ -44,8 +44,33 @@ async function requestPiAddition(req, res, dependencies, config) {
             .collection('requests')
             .doc(requestId);
         
+        // Write to global collection
         await requestRef.set(requestData);
         
+        // Also write to user-centric collection (dual-write)
+        const { writeWithMigration } = require('../core/path_resolution_helpers');
+        try {
+            await writeWithMigration(
+                db,
+                'signedInUsers',
+                'piAdditionRequests',
+                { cid: userCid },
+                requestData,
+                {
+                    isCollection: true,
+                    merge: false,
+                    dataType: 'piAdditionRequests',
+                    config,
+                    documentId: requestId,
+                    dualWrite: false, // Don't dual-write to legacy (new feature)
+                    collectionRegistry: dependencies.collectionRegistry
+                }
+            );
+        } catch (userWriteErr) {
+            // Log but don't fail - global write succeeded
+            logger.log('WARN', `[requestPiAddition] Failed to write to user-centric collection: ${userWriteErr.message}`);
+        }
+        
         logger.log('SUCCESS', `[requestPiAddition] User ${userCid} requested addition of PI ${piUsername} (CID: ${piCid || 'unknown'})`);
         
         return res.status(201).json({

package/functions/task-engine/helpers/data_storage_helpers.js

@@ -36,6 +36,10 @@ async function storeSignedInUserPortfolio({ db, logger, collectionRegistry, cid,
     }, { merge: false });
     
     // 2. Store latest snapshot to user-centric collection (for fallback)
+    const { getCollectionPath } = collectionRegistry || {};
+    if (!getCollectionPath) {
+        throw new Error('collectionRegistry.getCollectionPath is required');
+    }
     const userLatestRef = db.collection(
         getCollectionPath('signedInUsers', 'portfolio', { cid })
     ).doc('latest');
@@ -76,6 +80,10 @@ async function storeSignedInUserTradeHistory({ db, logger, collectionRegistry, c
     }, { merge: false });
     
     // 2. Store latest snapshot to user-centric collection (for fallback)
+    const { getCollectionPath } = collectionRegistry || {};
+    if (!getCollectionPath) {
+        throw new Error('collectionRegistry.getCollectionPath is required');
+    }
     const userLatestRef = db.collection(
         getCollectionPath('signedInUsers', 'tradeHistory', { cid })
     ).doc('latest');
@@ -124,8 +132,12 @@ async function storeSignedInUserSocialPosts({ db, logger, collectionRegistry, ci
     }, { merge: false });
     
     // 2. Store latest posts to user-centric collection (for fallback)
+    const { getCollectionPath } = collectionRegistry || {};
+    if (!getCollectionPath) {
+        throw new Error('collectionRegistry.getCollectionPath is required');
+    }
     const userPostsRef = db.collection(
-        getCollectionPath('signedInUsers', 'posts', { cid })
+        getCollectionPath('signedInUsers', 'socialPosts', { cid })
     );
     
     // Store each post individually in user-centric collection

package/functions/task-engine/helpers/popular_investor_helpers.js

@@ -21,7 +21,10 @@ const { shouldTryProxy, recordProxyOutcome, getFailureCount, getMaxFailures } =
 const { 
     storePopularInvestorPortfolio, 
     storePopularInvestorTradeHistory, 
-    storePopularInvestorSocialPosts 
+    storePopularInvestorSocialPosts,
+    storeSignedInUserPortfolio,
+    storeSignedInUserTradeHistory,
+    storeSignedInUserSocialPosts
 } = require('./data_storage_helpers');
 
 async function handlePopularInvestorUpdate(taskData, config, dependencies) {
@@ -526,9 +529,10 @@ async function handleOnDemandUserUpdate(taskData, config, dependencies) {
     // Extract targetCid from metadata if present (for optimization)
     const targetCid = metadata?.targetCid || cid;
     const isNewUser = metadata?.isNewUser === true; // Flag for new user signup
+    const userType = metadata?.userType || data.userType || 'SIGNED_IN_USER'; // Check if this is a PI or signed-in user
     
     // [FIX] Destructure dependencies first
-    const { logger, proxyManager, batchManager, headerManager, db } = dependencies;
+    const { logger, proxyManager, batchManager, headerManager, db, collectionRegistry } = dependencies;
     
     // Import notification helper once at the top
     const { notifyTaskEngineComplete } = require('../../generic-api/user-api/helpers/notification_helpers');
@@ -687,14 +691,26 @@ async function handleOnDemandUserUpdate(taskData, config, dependencies) {
             portfolioFetched = true;
 
             try {
-                await storeSignedInUserPortfolio({
-                    db,
-                    logger,
-                    collectionRegistry,
-                    cid: String(cid),
-                    date: today,
-                    portfolioData
-                });
+                // Use correct storage function based on user type
+                if (userType === 'POPULAR_INVESTOR') {
+                    await storePopularInvestorPortfolio({
+                        db,
+                        logger,
+                        collectionRegistry,
+                        cid: String(cid),
+                        date: today,
+                        portfolioData
+                    });
+                } else {
+                    await storeSignedInUserPortfolio({
+                        db,
+                        logger,
+                        collectionRegistry,
+                        cid: String(cid),
+                        date: today,
+                        portfolioData
+                    });
+                }
             } catch (batchErr) {
                 const errorMsg = `Failed to store portfolio data: ${batchErr.message}`;
                 logger.log('ERROR', `[On-Demand] ${errorMsg}`, batchErr);
@@ -765,14 +781,26 @@ async function handleOnDemandUserUpdate(taskData, config, dependencies) {
                 }
                 
                 try {
-                    await storeSignedInUserTradeHistory({
-                        db,
-                        logger,
-                        collectionRegistry,
-                        cid: String(cid),
-                        date: today,
-                        historyData
-                    });
+                    // Use correct storage function based on user type
+                    if (userType === 'POPULAR_INVESTOR') {
+                        await storePopularInvestorTradeHistory({
+                            db,
+                            logger,
+                            collectionRegistry,
+                            cid: String(cid),
+                            date: today,
+                            historyData
+                        });
+                    } else {
+                        await storeSignedInUserTradeHistory({
+                            db,
+                            logger,
+                            collectionRegistry,
+                            cid: String(cid),
+                            date: today,
+                            historyData
+                        });
+                    }
                     historyFetched = true;
                 } catch (batchErr) {
                     const errorMsg = `Failed to store history data: ${batchErr.message}`;
@@ -872,14 +900,26 @@ async function handleOnDemandUserUpdate(taskData, config, dependencies) {
                     
                     // Store posts using new structure
                     if (postsToStore.length > 0) {
-                        await storeSignedInUserSocialPosts({
-                            db,
-                            logger,
-                            collectionRegistry,
-                            cid: String(cid),
-                            date: today,
-                            posts: postsToStore
-                        });
+                        // Use correct storage function based on user type
+                        if (userType === 'POPULAR_INVESTOR') {
+                            await storePopularInvestorSocialPosts({
+                                db,
+                                logger,
+                                collectionRegistry,
+                                cid: String(cid),
+                                date: today,
+                                posts: postsToStore
+                            });
+                        } else {
+                            await storeSignedInUserSocialPosts({
+                                db,
+                                logger,
+                                collectionRegistry,
+                                cid: String(cid),
+                                date: today,
+                                posts: postsToStore
+                            });
+                        }
                         
                         // Update date tracking document (for root data indexer)
                         const { getCollectionPath } = collectionRegistry;

package/package.json

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