bulltrackers-module 1.0.532 → 1.0.534

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

@@ -28,10 +28,25 @@ try {
 function getRegistryFunctions(options = {}) {
     // Try to get from options first (injected)
     if (options.collectionRegistry) {
+        // Try to get getCollectionMetadata from injected registry, fallback to module-level if not available
+        let getMetadata = options.collectionRegistry.getCollectionMetadata;
+        if (!getMetadata && getCollectionMetadata) {
+            getMetadata = getCollectionMetadata;
+        }
+        // If still not available, try requiring the registry
+        if (!getMetadata) {
+            try {
+                const registryFallback = require('../../../../../../config/collection_registry');
+                getMetadata = registryFallback.getCollectionMetadata;
+            } catch (e) {
+                // getMetadata will be undefined, which is fine - we'll handle it gracefully
+            }
+        }
+        
         return {
             getCollectionPath: options.collectionRegistry.getCollectionPath,
             resolvePath: options.collectionRegistry.resolvePath || resolvePath,
-            getCollectionMetadata: options.collectionRegistry.getCollectionMetadata
+            getCollectionMetadata: getMetadata
         };
     }
     
@@ -42,14 +57,19 @@ function getRegistryFunctions(options = {}) {
     
     // Last resort: try to require again (in case it's available now)
     try {
-        const registry = require('../../../../../../config/collection_registry');
+        const registryLastResort = require('../../../../../../config/collection_registry');
         return {
-            getCollectionPath: registry.getCollectionPath,
-            resolvePath: registry.resolvePath,
-            getCollectionMetadata: registry.getCollectionMetadata
+            getCollectionPath: registryLastResort.getCollectionPath,
+            resolvePath: registryLastResort.resolvePath,
+            getCollectionMetadata: registryLastResort.getCollectionMetadata
         };
     } catch (error) {
-        throw new Error('Collection registry functions not available. Please provide collectionRegistry in dependencies.');
+        // Return functions that might be available, with getCollectionMetadata as undefined
+        return {
+            getCollectionPath: getCollectionPath || null,
+            resolvePath: resolvePath || null,
+            getCollectionMetadata: getCollectionMetadata || null
+        };
     }
 }
 
@@ -120,47 +140,49 @@ function getLegacyPath(dataType, userCid, config = {}, params = {}, category = n
             const getMetadata = registryFuncs.getCollectionMetadata;
             const resolve = registryFuncs.resolvePath;
             
-            // Check if getCollectionMetadata is available
-            if (!getMetadata || typeof getMetadata !== 'function') {
-                throw new Error('getCollectionMetadata is not available');
-            }
-            
-            const metadata = getMetadata(category, subcategory);
-            if (metadata && metadata.legacyPaths && metadata.legacyPaths.length > 0) {
-                // Use first legacy path from registry (can be enhanced to try multiple)
-                let legacyPathTemplate = metadata.legacyPaths[0];
-                
-                // Resolve dynamic segments in the legacy path
-                const cid = String(userCid);
-                const resolvedParams = {
-                    cid: cid,
-                    userCid: cid,
-                    firebaseUid: params.firebaseUid || '',
-                    username: params.username || '',
-                    date: params.date || '{date}',
-                    requestId: params.requestId || '{requestId}',
-                    piCid: params.piCid || cid,
-                    reviewId: params.reviewId || `{piCid}_{userCid}`,
-                    postId: params.postId || '{postId}',
-                    viewId: params.viewId || `{piCid}_{viewerCid}_{timestamp}`,
-                    watchlistId: params.watchlistId || '{watchlistId}',
-                    version: params.version || '{version}',
-                    ...params // Allow params to override defaults
-                };
-                
-                // Resolve path template
-                legacyPathTemplate = resolve(legacyPathTemplate, resolvedParams);
-                
-                // Replace any remaining placeholders
-                for (const [key, value] of Object.entries(resolvedParams)) {
-                    legacyPathTemplate = legacyPathTemplate.replace(`{${key}}`, String(value));
+            // Check if getCollectionMetadata is available - if not, fall through to hardcoded map
+            if (getMetadata && typeof getMetadata === 'function') {
+                const metadata = getMetadata(category, subcategory);
+                if (metadata && metadata.legacyPaths && metadata.legacyPaths.length > 0) {
+                    // Use first legacy path from registry (can be enhanced to try multiple)
+                    let legacyPathTemplate = metadata.legacyPaths[0];
+                    
+                    // Resolve dynamic segments in the legacy path
+                    const cid = String(userCid);
+                    const resolvedParams = {
+                        cid: cid,
+                        userCid: cid,
+                        firebaseUid: params.firebaseUid || '',
+                        username: params.username || '',
+                        date: params.date || '{date}',
+                        requestId: params.requestId || '{requestId}',
+                        piCid: params.piCid || cid,
+                        reviewId: params.reviewId || `{piCid}_{userCid}`,
+                        postId: params.postId || '{postId}',
+                        viewId: params.viewId || `{piCid}_{viewerCid}_{timestamp}`,
+                        watchlistId: params.watchlistId || '{watchlistId}',
+                        version: params.version || '{version}',
+                        ...params // Allow params to override defaults
+                    };
+                    
+                    // Resolve path template
+                    legacyPathTemplate = resolve(legacyPathTemplate, resolvedParams);
+                    
+                    // Replace any remaining placeholders
+                    for (const [key, value] of Object.entries(resolvedParams)) {
+                        legacyPathTemplate = legacyPathTemplate.replace(`{${key}}`, String(value));
+                    }
+                    
+                    return legacyPathTemplate;
                 }
-                
-                return legacyPathTemplate;
+                // If metadata exists but no legacyPaths, fall through to hardcoded map
             }
         } catch (error) {
             // Fall through to hardcoded map if registry lookup fails
-            console.warn(`[getLegacyPath] Could not get legacy path from registry for ${category}/${subcategory}:`, error.message);
+            // Only log if it's not the expected "not available" error
+            if (error.message !== 'getCollectionMetadata is not available') {
+                console.warn(`[getLegacyPath] Could not get legacy path from registry for ${category}/${subcategory}:`, error.message);
+            }
         }
     }
     

package/functions/task-engine/handler_creator.js

@@ -257,7 +257,13 @@ async function handleRequest(message, context, configObj, dependencies) {
         }
 
     } catch (err) {
-        logger.log('ERROR', `[TaskEngine] Error processing task ${type}.`, { error: err.message });
+        const errorMessage = err.message || String(err);
+        const errorStack = err.stack || '';
+        logger.log('ERROR', `[TaskEngine] Error processing task ${type}: ${errorMessage}`, { 
+            error: errorMessage,
+            stack: errorStack,
+            taskType: type
+        });
     }
 }
 

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

@@ -235,15 +235,26 @@ async function handleGenericUserUpdate(taskData, config, dependencies, isPI) {
         }
 
     } catch (err) {
-        logger.log('ERROR', `[Update] Failed for ${username}`, err);
+        // Log error with full details
+        const errorMessage = err.message || String(err);
+        const errorStack = err.stack || '';
+        logger.log('ERROR', `[Update] Failed for ${username}: ${errorMessage}`, {
+            error: errorMessage,
+            stack: errorStack,
+            cid,
+            username,
+            requestId,
+            isPI
+        });
+        
         // Mark Failed
         if (requestId && db) {
             const reqRef = db.collection(source === 'on_demand_sync' ? 'user_sync_requests' : 'pi_fetch_requests')
                            .doc(String(cid)).collection('requests').doc(requestId);
-            await reqRef.update({ status: 'failed', error: err.message, failedAt: FieldValue.serverTimestamp() });
+            await reqRef.update({ status: 'failed', error: errorMessage, failedAt: FieldValue.serverTimestamp() });
             
             if (metadata?.requestingUserCid) {
-                notifyTaskEngineComplete(db, logger, metadata.requestingUserCid, requestId, username, false, err.message).catch(()=>{});
+                notifyTaskEngineComplete(db, logger, metadata.requestingUserCid, requestId, username, false, errorMessage).catch(()=>{});
             }
         }
         throw err;

package/package.json

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