bulltrackers-module 1.0.629 → 1.0.631

package/functions/old-generic-api/user-api/helpers/watchlist/watchlist_management_helpers.js

@@ -1,829 +0,0 @@
-/**
- * @fileoverview Watchlist Management Helpers
- * Handles CRUD operations for user watchlists (static and dynamic)
- */
-
-const { FieldValue } = require('@google-cloud/firestore');
-const crypto = require('crypto');
-
-/**
- * Generate unique watchlist ID
- */
-function generateWatchlistId() {
-    return `watchlist_${Date.now()}_${crypto.randomBytes(4).toString('hex')}`;
-}
-
-/**
- * GET /user/me/watchlists
- * List all watchlists for a user
- */
-async function getUserWatchlists(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    
-    if (!userCid) {
-        return res.status(400).json({ error: "Missing userCid" });
-    }
-    
-    try {
-        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
-        const userWatchlistsRef = db.collection(watchlistsCollection)
-            .doc(String(userCid))
-            .collection('lists');
-        
-        const snapshot = await userWatchlistsRef.get();
-        
-        const watchlists = [];
-        snapshot.forEach(doc => {
-            watchlists.push({
-                id: doc.id,
-                ...doc.data()
-            });
-        });
-        
-        // Sort by creation date (newest first)
-        watchlists.sort((a, b) => {
-            const aTime = a.createdAt?.seconds || 0;
-            const bTime = b.createdAt?.seconds || 0;
-            return bTime - aTime;
-        });
-        
-        return res.status(200).json({
-            watchlists,
-            count: watchlists.length
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[getUserWatchlists] Error fetching watchlists for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/me/watchlists/:id
- * Get a specific watchlist
- */
-async function getWatchlist(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    const { id } = req.params;
-    
-    if (!userCid || !id) {
-        return res.status(400).json({ error: "Missing userCid or watchlist id" });
-    }
-    
-    try {
-        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) {
-            return res.status(404).json({ error: "Watchlist not found" });
-        }
-        
-        return res.status(200).json({
-            id: watchlistDoc.id,
-            ...watchlistDoc.data()
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[getWatchlist] Error fetching watchlist ${id} for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * POST /user/me/watchlists
- * Create a new watchlist
- */
-async function createWatchlist(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid, name, type, visibility = 'private', items, dynamicConfig } = req.body;
-    
-    if (!userCid || !name || !type) {
-        return res.status(400).json({ error: "Missing required fields: userCid, name, type" });
-    }
-    
-    if (type !== 'static' && type !== 'dynamic') {
-        return res.status(400).json({ error: "Type must be 'static' or 'dynamic'" });
-    }
-    
-    if (visibility !== 'public' && visibility !== 'private') {
-        return res.status(400).json({ error: "Visibility must be 'public' or 'private'" });
-    }
-    
-    try {
-        const watchlistsCollection = config.watchlistsCollection || 'watchlists';
-        const watchlistId = generateWatchlistId();
-        
-        const watchlistData = {
-            id: watchlistId,
-            name: name.trim(),
-            type,
-            visibility,
-            createdBy: Number(userCid),
-            createdAt: FieldValue.serverTimestamp(),
-            updatedAt: FieldValue.serverTimestamp(),
-            isAutoGenerated: false,
-            copyCount: 0
-        };
-        
-        if (type === 'static') {
-            watchlistData.items = items || [];
-        } else if (type === 'dynamic') {
-            if (!dynamicConfig || !dynamicConfig.computationName) {
-                return res.status(400).json({ error: "Dynamic watchlists require dynamicConfig with computationName" });
-            }
-            watchlistData.dynamicConfig = dynamicConfig;
-        }
-        
-        // Write to new SignedInUsers path with dual-write to legacy path
-        const { writeWithMigration } = require('../core/path_resolution_helpers');
-        await writeWithMigration(
-            db,
-            'signedInUsers',
-            'watchlists',
-            { cid: userCid },
-            watchlistData,
-            {
-                isCollection: true,
-                merge: false,
-                dataType: 'watchlists',
-                config,
-                collectionRegistry: dependencies.collectionRegistry,
-                documentId: watchlistId,
-                dualWrite: true
-            }
-        );
-        
-        // Update global rootdata collection for computation system if static watchlist has items
-        if (type === 'static' && items && items.length > 0) {
-            const { updateWatchlistMembershipRootData, updatePIWatchlistData } = require('../rootdata/rootdata_aggregation_helpers');
-            const today = new Date().toISOString().split('T')[0];
-            const isPublic = visibility === 'public';
-            
-            for (const item of items) {
-                const piCid = String(item.cid);
-                // Update global WatchlistMembershipData/{date} document
-                await updateWatchlistMembershipRootData(db, logger, piCid, userCid, isPublic, today, 'add');
-                // Update PI-centric PopularInvestors/{piCid}/watchlistData
-                await updatePIWatchlistData(db, logger, piCid, userCid, today, 'add');
-            }
-        }
-        
-        // Watchlists are always created as private - no public version on creation
-        
-        logger.log('SUCCESS', `[createWatchlist] Created ${type} watchlist "${name}" for user ${userCid}`);
-        
-        return res.status(201).json({
-            success: true,
-            watchlist: {
-                id: watchlistId,
-                ...watchlistData
-            }
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[createWatchlist] Error creating watchlist for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * PUT /user/me/watchlists/:id
- * Update a watchlist
- */
-async function updateWatchlist(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    const { id } = req.params;
-    const { name, visibility, items, dynamicConfig } = req.body;
-    
-    if (!userCid || !id) {
-        return res.status(400).json({ error: "Missing userCid or watchlist id" });
-    }
-    
-    try {
-        // Read from new path with migration fallback
-        const { readWithMigration } = require('../core/path_resolution_helpers');
-        const readResult = await readWithMigration(
-            db,
-            'signedInUsers',
-            'watchlists',
-            { cid: userCid },
-            {
-                isCollection: true,
-                dataType: 'watchlists',
-                config,
-                logger,
-                collectionRegistry: dependencies.collectionRegistry,
-                documentId: id
-            }
-        );
-        
-        if (!readResult) {
-            return res.status(404).json({ error: "Watchlist not found" });
-        }
-        
-        // Handle both document read (with data) and collection read (with snapshot)
-        let existingData;
-        if (readResult.data) {
-            existingData = readResult.data;
-        } else if (readResult.snapshot && !readResult.snapshot.empty) {
-            // If we got a snapshot, find the specific document
-            const doc = readResult.snapshot.docs.find(d => d.id === id);
-            if (!doc) {
-                return res.status(404).json({ error: "Watchlist not found" });
-            }
-            existingData = doc.data();
-        } else {
-            return res.status(404).json({ error: "Watchlist not found" });
-        }
-        
-        // Verify ownership
-        if (existingData.createdBy !== Number(userCid)) {
-            return res.status(403).json({ error: "You can only modify your own watchlists" });
-        }
-        
-        // Check if this is a copied watchlist
-        const isCopiedWatchlist = existingData.copiedFrom && existingData.copiedFromCreator;
-        const wasModified = existingData.hasBeenModified || false;
-        
-        // Determine if meaningful changes are being made (not just name)
-        let hasMeaningfulChanges = wasModified;
-        if (items !== undefined && existingData.type === 'static') {
-            // Check if items actually changed
-            const itemsChanged = JSON.stringify(items) !== JSON.stringify(existingData.items || []);
-            hasMeaningfulChanges = hasMeaningfulChanges || itemsChanged;
-        }
-        if (dynamicConfig !== undefined && existingData.type === 'dynamic') {
-            // Check if dynamicConfig actually changed
-            const configChanged = JSON.stringify(dynamicConfig) !== JSON.stringify(existingData.dynamicConfig || {});
-            hasMeaningfulChanges = hasMeaningfulChanges || configChanged;
-        }
-        
-        // If trying to make a copied watchlist public, check if meaningful changes were made
-        if (visibility === 'public' && isCopiedWatchlist && !hasMeaningfulChanges) {
-            return res.status(400).json({ 
-                error: "Cannot publish copied watchlist without making meaningful changes. Please modify the watchlist items, thresholds, or parameters before publishing." 
-            });
-        }
-        
-        const updates = {
-            updatedAt: FieldValue.serverTimestamp()
-        };
-        
-        if (name !== undefined) {
-            updates.name = name.trim();
-        }
-        
-        // Track if watchlist has been modified (for copied watchlists)
-        if (isCopiedWatchlist && hasMeaningfulChanges) {
-            updates.hasBeenModified = true;
-        }
-        
-        // Visibility changes are now handled through publish/unpublish endpoints
-        // Users can only update their private watchlist
-        if (visibility !== undefined && visibility !== 'private') {
-            return res.status(400).json({ 
-                error: "Cannot change visibility directly. Use the publish endpoint to create a public version." 
-            });
-        }
-        
-        if (items !== undefined && existingData.type === 'static') {
-            updates.items = items;
-            
-            // Update global rootdata collection for computation system
-            // Compare old and new items to find added/removed PIs
-            const { updateWatchlistMembershipRootData, updatePIWatchlistData } = require('../rootdata/rootdata_aggregation_helpers');
-            const oldItems = existingData.items || [];
-            const newItems = items || [];
-            const oldPiCids = new Set(oldItems.map(item => String(item.cid)));
-            const newPiCids = new Set(newItems.map(item => String(item.cid)));
-            const today = new Date().toISOString().split('T')[0];
-            const isPublic = existingData.visibility === 'public';
-            
-            // Find added PIs
-            for (const newItem of newItems) {
-                const piCid = String(newItem.cid);
-                if (!oldPiCids.has(piCid)) {
-                    // Update global WatchlistMembershipData/{date} document
-                    await updateWatchlistMembershipRootData(db, logger, piCid, userCid, isPublic, today, 'add');
-                    // Update PI-centric PopularInvestors/{piCid}/watchlistData
-                    await updatePIWatchlistData(db, logger, piCid, userCid, today, 'add');
-                }
-            }
-            
-            // Find removed PIs
-            for (const oldItem of oldItems) {
-                const piCid = String(oldItem.cid);
-                if (!newPiCids.has(piCid)) {
-                    // Update global WatchlistMembershipData/{date} document
-                    await updateWatchlistMembershipRootData(db, logger, piCid, userCid, isPublic, today, 'remove');
-                    // Update PI-centric PopularInvestors/{piCid}/watchlistData
-                    await updatePIWatchlistData(db, logger, piCid, userCid, today, 'remove');
-                }
-            }
-        }
-        
-        if (dynamicConfig !== undefined && existingData.type === 'dynamic') {
-            updates.dynamicConfig = dynamicConfig;
-        }
-        
-        // Merge updates with existing data
-        const updatedData = { ...existingData, ...updates };
-        
-        // Write to new SignedInUsers path with dual-write to legacy path
-        const { writeWithMigration } = require('../core/path_resolution_helpers');
-        await writeWithMigration(
-            db,
-            'signedInUsers',
-            'watchlists',
-            { cid: userCid },
-            updatedData,
-            {
-                isCollection: true,
-                merge: true,
-                dataType: 'watchlists',
-                config,
-                collectionRegistry: dependencies.collectionRegistry,
-                documentId: id,
-                dualWrite: true
-            }
-        );
-        
-        logger.log('SUCCESS', `[updateWatchlist] Updated watchlist ${id} for user ${userCid}`);
-        
-        return res.status(200).json({
-            success: true,
-            watchlist: {
-                id: id,
-                ...updatedData
-            }
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[updateWatchlist] Error updating watchlist ${id} for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * DELETE /user/me/watchlists/:id
- * Delete a watchlist
- */
-async function deleteWatchlist(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    const { id } = req.params;
-    
-    if (!userCid || !id) {
-        return res.status(400).json({ error: "Missing userCid or watchlist id" });
-    }
-    
-    try {
-        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) {
-            return res.status(404).json({ error: "Watchlist not found" });
-        }
-        
-        const watchlistData = watchlistDoc.data();
-        
-        // Verify ownership
-        if (watchlistData.createdBy !== Number(userCid)) {
-            return res.status(403).json({ error: "You can only delete your own watchlists" });
-        }
-        
-        // Update global rootdata collections before deleting
-        // Remove all PIs from global tracking if this is a static watchlist with items
-        if (watchlistData.type === 'static' && watchlistData.items && watchlistData.items.length > 0) {
-            const { updateWatchlistMembershipRootData, updatePIWatchlistData } = require('../rootdata/rootdata_aggregation_helpers');
-            const today = new Date().toISOString().split('T')[0];
-            const isPublic = watchlistData.visibility === 'public';
-            
-            for (const item of watchlistData.items) {
-                const piCid = String(item.cid);
-                // Remove from global WatchlistMembershipData/{date} document
-                await updateWatchlistMembershipRootData(db, logger, piCid, userCid, isPublic, today, 'remove');
-                // Remove from PI-centric PopularInvestors/{piCid}/watchlistData
-                await updatePIWatchlistData(db, logger, piCid, userCid, today, 'remove');
-            }
-        }
-        
-        // Delete watchlist from both new and legacy paths
-        const { writeWithMigration } = require('../core/path_resolution_helpers');
-        // Delete from new path
-        const newPathRef = db.collection('SignedInUsers')
-            .doc(String(userCid))
-            .collection('watchlists')
-            .doc(id);
-        await newPathRef.delete().catch(err => {
-            logger.log('WARN', `[deleteWatchlist] Failed to delete from new path: ${err.message}`);
-        });
-        
-        // Delete from legacy path if it exists
-        const legacyPathRef = db.collection(config.watchlistsCollection || 'watchlists')
-            .doc(String(userCid))
-            .collection('lists')
-            .doc(id);
-        await legacyPathRef.delete().catch(err => {
-            logger.log('WARN', `[deleteWatchlist] Failed to delete from legacy path: ${err.message}`);
-        });
-        
-        // Remove from public watchlists if it was public
-        if (watchlistData.visibility === 'public') {
-            const publicRef = db.collection('public_watchlists').doc(id);
-            await publicRef.delete();
-        }
-        
-        // TODO: Clean up subscriptions for this watchlist
-        // This would require deleting entries in watchlist_subscriptions collection
-        
-        logger.log('SUCCESS', `[deleteWatchlist] Deleted watchlist ${id} for user ${userCid}`);
-        
-        return res.status(200).json({
-            success: true,
-            message: "Watchlist deleted successfully"
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[deleteWatchlist] Error deleting watchlist ${id} for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * POST /user/me/watchlists/:id/copy
- * Copy a public watchlist
- */
-async function copyWatchlist(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    const { id } = req.params;
-    const { name, version } = req.body; // Optional custom name and version number
-    
-    if (!userCid || !id) {
-        return res.status(400).json({ error: "Missing userCid or watchlist id" });
-    }
-    
-    const userCidNum = Number(userCid);
-    
-    try {
-        // First, try to find in public watchlists
-        const publicRef = db.collection('public_watchlists').doc(id);
-        const publicDoc = await publicRef.get();
-        
-        if (!publicDoc.exists) {
-            return res.status(404).json({ error: "Public watchlist not found" });
-        }
-        
-        const publicData = publicDoc.data();
-        const originalCreatorCid = Number(publicData.createdBy);
-        
-        let originalData;
-        
-        // If version is specified, copy from that specific version snapshot
-        if (version) {
-            const versionRef = db.collection('public_watchlists')
-                .doc(id)
-                .collection('versions')
-                .doc(String(version));
-            
-            const versionDoc = await versionRef.get();
-            
-            if (!versionDoc.exists) {
-                return res.status(404).json({ error: `Version ${version} not found for this watchlist` });
-            }
-            
-            originalData = versionDoc.data();
-        } else {
-            // Copy from latest version (get the latest version)
-            const latestVersion = publicData.latestVersion || 1;
-            const versionRef = db.collection('public_watchlists')
-                .doc(id)
-                .collection('versions')
-                .doc(String(latestVersion));
-            
-            const versionDoc = await versionRef.get();
-            
-            if (versionDoc.exists) {
-                originalData = versionDoc.data();
-            } else {
-                // Fallback: try to get from original watchlist (for backwards compatibility)
-                const originalRef = db.collection(config.watchlistsCollection || 'watchlists')
-                    .doc(String(originalCreatorCid))
-                    .collection('lists')
-                    .doc(id);
-                
-                const originalDoc = await originalRef.get();
-                
-                if (!originalDoc.exists) {
-                    return res.status(404).json({ error: "Original watchlist not found" });
-                }
-                
-                originalData = originalDoc.data();
-            }
-        }
-        
-        // Check if user is copying their own watchlist
-        const isCopyingOwn = originalCreatorCid === userCidNum;
-        
-        // If copying own watchlist, find existing copies to determine number
-        let copyNumber = 1;
-        let newName = name;
-        
-        if (isCopyingOwn) {
-            // Get all watchlists by this user to find existing copies
-            const userWatchlistsRef = db.collection(config.watchlistsCollection || 'watchlists')
-                .doc(String(userCidNum))
-                .collection('lists');
-            
-            const userWatchlistsSnapshot = await userWatchlistsRef.get();
-            const baseName = originalData.name.replace(/\s*#\d+$/, ''); // Remove existing #N suffix
-            
-            // Count existing copies (including original)
-            const existingCopies = [];
-            userWatchlistsSnapshot.forEach(doc => {
-                const data = doc.data();
-                const docName = data.name.replace(/\s*#\d+$/, '');
-                if (docName === baseName || docName === originalData.name) {
-                    existingCopies.push(data);
-                }
-            });
-            
-            // Determine next copy number
-            copyNumber = existingCopies.length + 1;
-            newName = name || `${baseName} #${copyNumber}`;
-        } else {
-            // Copying someone else's watchlist
-            newName = name || `${originalData.name} (Copy)`;
-        }
-        
-        // Create new watchlist for the copying user
-        const newWatchlistId = generateWatchlistId();
-        const watchlistData = {
-            ...originalData,
-            id: newWatchlistId,
-            name: newName,
-            createdBy: userCidNum,
-            visibility: 'private', // Copied watchlists are always private
-            copiedFrom: id,
-            copiedFromVersion: version || (publicData.latestVersion || 1), // Track which version was copied
-            copiedFromCreator: originalCreatorCid,
-            originalName: originalData.name, // Store original name for comparison
-            hasBeenModified: false, // Track if user made meaningful changes
-            createdAt: FieldValue.serverTimestamp(),
-            updatedAt: FieldValue.serverTimestamp(),
-            isAutoGenerated: false
-        };
-        
-        // Remove fields that shouldn't be copied
-        delete watchlistData.copyCount;
-        delete watchlistData.version;
-        delete watchlistData.versionId;
-        delete watchlistData.snapshotAt;
-        delete watchlistData.isImmutable;
-        delete watchlistData.watchlistId;
-        
-        const newWatchlistRef = db.collection(config.watchlistsCollection || 'watchlists')
-            .doc(String(userCidNum))
-            .collection('lists')
-            .doc(newWatchlistId);
-        
-        await newWatchlistRef.set(watchlistData);
-        
-        // Increment copy count on original (only if copying someone else's)
-        if (!isCopyingOwn) {
-            await publicRef.update({
-                copyCount: FieldValue.increment(1),
-                updatedAt: FieldValue.serverTimestamp()
-            });
-        }
-        
-        logger.log('SUCCESS', `[copyWatchlist] User ${userCid} copied watchlist ${id} as ${newWatchlistId}${isCopyingOwn ? ' (own watchlist)' : ''}`);
-        
-        return res.status(201).json({
-            success: true,
-            watchlist: {
-                id: newWatchlistId,
-                ...watchlistData
-            }
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[copyWatchlist] Error copying watchlist ${id} for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/public-watchlists
- * Browse public watchlists
- */
-async function getPublicWatchlists(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { limit = 50, offset = 0 } = req.query;
-    
-    try {
-        const publicRef = db.collection('public_watchlists')
-            .orderBy('copyCount', 'desc')
-            .orderBy('createdAt', 'desc')
-            .limit(parseInt(limit))
-            .offset(parseInt(offset));
-        
-        const snapshot = await publicRef.get();
-        
-        const watchlists = [];
-        snapshot.forEach(doc => {
-            watchlists.push({
-                id: doc.id,
-                ...doc.data()
-            });
-        });
-        
-        return res.status(200).json({
-            watchlists,
-            count: watchlists.length,
-            limit: parseInt(limit),
-            offset: parseInt(offset)
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[getPublicWatchlists] Error fetching public watchlists`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * POST /user/me/watchlists/:id/publish
- * Publish a version of a private watchlist
- * Creates an immutable snapshot version that can be copied by others
- */
-async function publishWatchlistVersion(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { userCid } = req.query;
-    const { id } = req.params;
-    
-    if (!userCid || !id) {
-        return res.status(400).json({ error: "Missing userCid or watchlist id" });
-    }
-    
-    try {
-        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) {
-            return res.status(404).json({ error: "Watchlist not found" });
-        }
-        
-        const watchlistData = watchlistDoc.data();
-        
-        // Verify ownership
-        if (watchlistData.createdBy !== Number(userCid)) {
-            return res.status(403).json({ error: "You can only publish your own watchlists" });
-        }
-        
-        // Check if this is a copied watchlist that hasn't been modified
-        if (watchlistData.copiedFrom && watchlistData.copiedFromCreator && !watchlistData.hasBeenModified) {
-            return res.status(400).json({ 
-                error: "Cannot publish copied watchlist without making meaningful changes. Please modify the watchlist items, thresholds, or parameters before publishing." 
-            });
-        }
-        
-        // Get current version number
-        const publicRef = db.collection('public_watchlists').doc(id);
-        const publicDoc = await publicRef.get();
-        
-        let versionNumber = 1;
-        if (publicDoc.exists) {
-            const publicData = publicDoc.data();
-            versionNumber = (publicData.latestVersion || 0) + 1;
-        }
-        
-        // Create version snapshot
-        const versionId = `${id}_v${versionNumber}`;
-        const versionData = {
-            watchlistId: id,
-            version: versionNumber,
-            createdBy: Number(userCid),
-            name: watchlistData.name,
-            type: watchlistData.type,
-            description: watchlistData.dynamicConfig?.description || '',
-            snapshotAt: FieldValue.serverTimestamp(),
-            copyCount: 0,
-            createdAt: watchlistData.createdAt,
-            isImmutable: true // Public versions are immutable
-        };
-        
-        // Only include items if it's a static watchlist
-        if (watchlistData.type === 'static' && watchlistData.items) {
-            versionData.items = JSON.parse(JSON.stringify(watchlistData.items));
-        }
-        
-        // Only include dynamicConfig if it's a dynamic watchlist
-        if (watchlistData.type === 'dynamic' && watchlistData.dynamicConfig) {
-            versionData.dynamicConfig = JSON.parse(JSON.stringify(watchlistData.dynamicConfig));
-        }
-        
-        // Store version in versions subcollection
-        const versionRef = db.collection('public_watchlists')
-            .doc(id)
-            .collection('versions')
-            .doc(String(versionNumber));
-        
-        await versionRef.set(versionData);
-        
-        // Update or create public watchlist entry (points to latest version)
-        await publicRef.set({
-            watchlistId: id,
-            createdBy: Number(userCid),
-            name: watchlistData.name,
-            type: watchlistData.type,
-            description: watchlistData.dynamicConfig?.description || '',
-            latestVersion: versionNumber,
-            latestVersionId: versionId,
-            copyCount: publicDoc.exists ? (publicDoc.data().copyCount || 0) : 0,
-            createdAt: watchlistData.createdAt,
-            updatedAt: FieldValue.serverTimestamp()
-        }, { merge: true });
-        
-        logger.log('SUCCESS', `[publishWatchlistVersion] User ${userCid} published watchlist ${id} as version ${versionNumber}`);
-        
-        return res.status(201).json({
-            success: true,
-            version: versionNumber,
-            versionId: versionId,
-            watchlist: versionData
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[publishWatchlistVersion] Error publishing watchlist ${id} for ${userCid}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-/**
- * GET /user/public-watchlists/:id/versions
- * Get version history for a public watchlist
- */
-async function getWatchlistVersions(req, res, dependencies, config) {
-    const { db, logger } = dependencies;
-    const { id } = req.params;
-    
-    try {
-        const versionsRef = db.collection('public_watchlists')
-            .doc(id)
-            .collection('versions')
-            .orderBy('version', 'desc');
-        
-        const snapshot = await versionsRef.get();
-        const versions = [];
-        
-        snapshot.forEach(doc => {
-            versions.push({
-                version: doc.data().version,
-                versionId: `${id}_v${doc.data().version}`,
-                ...doc.data()
-            });
-        });
-        
-        return res.status(200).json({
-            success: true,
-            watchlistId: id,
-            versions,
-            count: versions.length
-        });
-        
-    } catch (error) {
-        logger.log('ERROR', `[getWatchlistVersions] Error fetching versions for ${id}`, error);
-        return res.status(500).json({ error: error.message });
-    }
-}
-
-module.exports = {
-    getUserWatchlists,
-    getWatchlist,
-    createWatchlist,
-    updateWatchlist,
-    deleteWatchlist,
-    copyWatchlist,
-    getPublicWatchlists,
-    publishWatchlistVersion,
-    getWatchlistVersions
-};