Run database migrations when opening board. Not when updating WeKan.

Thanks to xet7 !

client/lib/boardConverter.js

@@ -0,0 +1,203 @@
+/**
+ * Board Conversion Service
+ * Handles conversion of boards from old database structure to new structure
+ * without running migrations that could cause downtime
+ */
+
+import { ReactiveVar } from 'meteor/reactive-var';
+import { ReactiveCache } from '/imports/lib/reactiveCache';
+
+// Reactive variables for conversion progress
+export const conversionProgress = new ReactiveVar(0);
+export const conversionStatus = new ReactiveVar('');
+export const conversionEstimatedTime = new ReactiveVar('');
+export const isConverting = new ReactiveVar(false);
+
+class BoardConverter {
+  constructor() {
+    this.conversionCache = new Map(); // Cache converted board IDs
+  }
+
+  /**
+   * Check if a board needs conversion
+   * @param {string} boardId - The board ID to check
+   * @returns {boolean} - True if board needs conversion
+   */
+  needsConversion(boardId) {
+    if (this.conversionCache.has(boardId)) {
+      return false; // Already converted
+    }
+
+    try {
+      const board = ReactiveCache.getBoard(boardId);
+      if (!board) return false;
+
+      // Check if any lists in this board don't have swimlaneId
+      const lists = ReactiveCache.getLists({
+        boardId: boardId,
+        $or: [
+          { swimlaneId: { $exists: false } },
+          { swimlaneId: '' },
+          { swimlaneId: null }
+        ]
+      });
+
+      return lists.length > 0;
+    } catch (error) {
+      console.error('Error checking if board needs conversion:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Convert a board from old structure to new structure
+   * @param {string} boardId - The board ID to convert
+   * @returns {Promise<boolean>} - True if conversion was successful
+   */
+  async convertBoard(boardId) {
+    if (this.conversionCache.has(boardId)) {
+      return true; // Already converted
+    }
+
+    isConverting.set(true);
+    conversionProgress.set(0);
+    conversionStatus.set('Starting board conversion...');
+
+    try {
+      const board = ReactiveCache.getBoard(boardId);
+      if (!board) {
+        throw new Error('Board not found');
+      }
+
+      // Get the default swimlane for this board
+      const defaultSwimlane = board.getDefaultSwimline();
+      if (!defaultSwimlane) {
+        throw new Error('No default swimlane found for board');
+      }
+
+      // Get all lists that need conversion
+      const listsToConvert = ReactiveCache.getLists({
+        boardId: boardId,
+        $or: [
+          { swimlaneId: { $exists: false } },
+          { swimlaneId: '' },
+          { swimlaneId: null }
+        ]
+      });
+
+      if (listsToConvert.length === 0) {
+        this.conversionCache.set(boardId, true);
+        isConverting.set(false);
+        return true;
+      }
+
+      conversionStatus.set(`Converting ${listsToConvert.length} lists...`);
+      
+      const startTime = Date.now();
+      const totalLists = listsToConvert.length;
+      let convertedLists = 0;
+
+      // Convert lists in batches to avoid blocking the UI
+      const batchSize = 10;
+      for (let i = 0; i < listsToConvert.length; i += batchSize) {
+        const batch = listsToConvert.slice(i, i + batchSize);
+        
+        // Process batch
+        await this.processBatch(batch, defaultSwimlane._id);
+        
+        convertedLists += batch.length;
+        const progress = Math.round((convertedLists / totalLists) * 100);
+        conversionProgress.set(progress);
+        
+        // Calculate estimated time remaining
+        const elapsed = Date.now() - startTime;
+        const rate = convertedLists / elapsed; // lists per millisecond
+        const remaining = totalLists - convertedLists;
+        const estimatedMs = remaining / rate;
+        
+        conversionStatus.set(`Converting list ${convertedLists} of ${totalLists}...`);
+        conversionEstimatedTime.set(this.formatTime(estimatedMs));
+
+        // Allow UI to update
+        await new Promise(resolve => setTimeout(resolve, 10));
+      }
+
+      // Mark as converted
+      this.conversionCache.set(boardId, true);
+      
+      conversionStatus.set('Board conversion completed!');
+      conversionProgress.set(100);
+      
+      // Clear status after a delay
+      setTimeout(() => {
+        isConverting.set(false);
+        conversionStatus.set('');
+        conversionProgress.set(0);
+        conversionEstimatedTime.set('');
+      }, 2000);
+
+      return true;
+
+    } catch (error) {
+      console.error('Error converting board:', error);
+      conversionStatus.set(`Conversion failed: ${error.message}`);
+      isConverting.set(false);
+      return false;
+    }
+  }
+
+  /**
+   * Process a batch of lists for conversion
+   * @param {Array} batch - Array of lists to convert
+   * @param {string} defaultSwimlaneId - Default swimlane ID
+   */
+  async processBatch(batch, defaultSwimlaneId) {
+    const updates = batch.map(list => ({
+      _id: list._id,
+      swimlaneId: defaultSwimlaneId
+    }));
+
+    // Update lists in batch
+    updates.forEach(update => {
+      ReactiveCache.getCollection('lists').update(update._id, {
+        $set: { swimlaneId: update.swimlaneId }
+      });
+    });
+  }
+
+  /**
+   * Format time in milliseconds to human readable format
+   * @param {number} ms - Time in milliseconds
+   * @returns {string} - Formatted time string
+   */
+  formatTime(ms) {
+    if (ms < 1000) {
+      return `${Math.round(ms)}ms`;
+    }
+
+    const seconds = Math.floor(ms / 1000);
+    const minutes = Math.floor(seconds / 60);
+    const hours = Math.floor(minutes / 60);
+
+    if (hours > 0) {
+      const remainingMinutes = minutes % 60;
+      const remainingSeconds = seconds % 60;
+      return `${hours}h ${remainingMinutes}m ${remainingSeconds}s`;
+    } else if (minutes > 0) {
+      const remainingSeconds = seconds % 60;
+      return `${minutes}m ${remainingSeconds}s`;
+    } else {
+      return `${seconds}s`;
+    }
+  }
+
+  /**
+   * Clear conversion cache (useful for testing)
+   */
+  clearCache() {
+    this.conversionCache.clear();
+  }
+}
+
+// Export singleton instance
+export const boardConverter = new BoardConverter();