Enhance metrics calculation scripts with improved progress tracking and cancellation support

2025-01-28 20:54:05 -05:00
parent a1e3803ca3
commit 9c34e24909
12 changed files with 915 additions and 327 deletions
--- a/inventory-server/scripts/metrics/brand-metrics.js
+++ b/inventory-server/scripts/metrics/brand-metrics.js
@@ -1,18 +1,32 @@
-const { outputProgress } = require('./utils/progress');
+const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');

-async function calculateBrandMetrics(startTime, totalProducts, processedCount) {
+async function calculateBrandMetrics(startTime, totalProducts, processedCount, isCancelled = false) {
    const connection = await getConnection();
    try {
+        if (isCancelled) {
+            outputProgress({
+                status: 'cancelled',
+                operation: 'Brand metrics calculation cancelled',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: null,
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
+            return processedCount;
+        }
+
        outputProgress({
            status: 'running',
-            operation: 'Calculating brand metrics',
-            current: Math.floor(totalProducts * 0.95),
+            operation: 'Starting brand metrics calculation',
+            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.95), totalProducts),
-            rate: calculateRate(startTime, Math.floor(totalProducts * 0.95)),
-            percentage: '95'
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
        });

        // Calculate brand metrics with optimized queries
@@ -111,6 +125,20 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount) {
                last_calculated_at = CURRENT_TIMESTAMP
        `);

+        processedCount = Math.floor(totalProducts * 0.97);
+        outputProgress({
+            status: 'running',
+            operation: 'Brand metrics calculated, starting time-based metrics',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Calculate brand time-based metrics with optimized query
        await connection.query(`
            INSERT INTO brand_time_metrics (
@@ -170,9 +198,26 @@ async function calculateBrandMetrics(startTime, totalProducts, processedCount) {
                avg_margin = VALUES(avg_margin)
        `);

-        return Math.floor(totalProducts * 0.98);
+        processedCount = Math.floor(totalProducts * 0.99);
+        outputProgress({
+            status: 'running',
+            operation: 'Brand time-based metrics calculated',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        return processedCount;
+    } catch (error) {
+        logError(error, 'Error calculating brand metrics');
+        throw error;
    } finally {
-        connection.release();
+        if (connection) {
+            connection.release();
+        }
    }
 }

--- a/inventory-server/scripts/metrics/category-metrics.js
+++ b/inventory-server/scripts/metrics/category-metrics.js
@@ -1,18 +1,32 @@
-const { outputProgress } = require('./utils/progress');
+const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');

-async function calculateCategoryMetrics(startTime, totalProducts, processedCount) {
+async function calculateCategoryMetrics(startTime, totalProducts, processedCount, isCancelled = false) {
    const connection = await getConnection();
    try {
+        if (isCancelled) {
+            outputProgress({
+                status: 'cancelled',
+                operation: 'Category metrics calculation cancelled',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: null,
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
+            return processedCount;
+        }
+
        outputProgress({
            status: 'running',
-            operation: 'Calculating category metrics',
-            current: Math.floor(totalProducts * 0.85),
+            operation: 'Starting category metrics calculation',
+            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.85), totalProducts),
-            rate: calculateRate(startTime, Math.floor(totalProducts * 0.85)),
-            percentage: '85'
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
        });
        
        // First, calculate base category metrics
@@ -44,6 +58,20 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
                last_calculated_at = VALUES(last_calculated_at)
        `);

+        processedCount = Math.floor(totalProducts * 0.90);
+        outputProgress({
+            status: 'running',
+            operation: 'Base category metrics calculated, updating with margin data',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Then update with margin and turnover data
        await connection.query(`
            WITH category_sales AS (
@@ -68,6 +96,20 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
                cm.last_calculated_at = NOW()
        `);

+        processedCount = Math.floor(totalProducts * 0.95);
+        outputProgress({
+            status: 'running',
+            operation: 'Margin data updated, calculating growth rates',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Finally update growth rates
        await connection.query(`
            WITH current_period AS (
@@ -112,6 +154,20 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
            WHERE cp.cat_id IS NOT NULL OR pp.cat_id IS NOT NULL
        `);

+        processedCount = Math.floor(totalProducts * 0.97);
+        outputProgress({
+            status: 'running',
+            operation: 'Growth rates calculated, updating time-based metrics',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Calculate time-based metrics
        await connection.query(`
            INSERT INTO category_time_metrics (
@@ -157,49 +213,26 @@ async function calculateCategoryMetrics(startTime, totalProducts, processedCount
                turnover_rate = VALUES(turnover_rate)
        `);

-        // Calculate sales metrics for different time periods
-        const periods = [30, 90, 180, 365];
-        for (const days of periods) {
-            await connection.query(`
-                INSERT INTO category_sales_metrics (
-                    category_id,
-                    brand,
-                    period_start,
-                    period_end,
-                    avg_daily_sales,
-                    total_sold,
-                    num_products,
-                    avg_price,
-                    last_calculated_at
-                )
-                SELECT 
-                    pc.cat_id as category_id,
-                    COALESCE(p.brand, 'Unbranded') as brand,
-                    DATE_SUB(CURDATE(), INTERVAL ? DAY) as period_start,
-                    CURDATE() as period_end,
-                    COALESCE(SUM(o.quantity), 0) / ? as avg_daily_sales,
-                    COALESCE(SUM(o.quantity), 0) as total_sold,
-                    COUNT(DISTINCT p.pid) as num_products,
-                    COALESCE(AVG(o.price), 0) as avg_price,
-                    NOW() as last_calculated_at
-                FROM product_categories pc
-                JOIN products p ON pc.pid = p.pid
-                LEFT JOIN orders o ON p.pid = o.pid 
-                    AND o.date >= DATE_SUB(CURDATE(), INTERVAL ? DAY)
-                    AND o.canceled = false
-                GROUP BY pc.cat_id, p.brand
-                ON DUPLICATE KEY UPDATE
-                    avg_daily_sales = VALUES(avg_daily_sales),
-                    total_sold = VALUES(total_sold),
-                    num_products = VALUES(num_products),
-                    avg_price = VALUES(avg_price),
-                    last_calculated_at = NOW()
-            `, [days, days, days]);
-        }
+        processedCount = Math.floor(totalProducts * 0.99);
+        outputProgress({
+            status: 'running',
+            operation: 'Time-based metrics calculated',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });

-        return Math.floor(totalProducts * 0.9);
+        return processedCount;
+    } catch (error) {
+        logError(error, 'Error calculating category metrics');
+        throw error;
    } finally {
-        connection.release();
+        if (connection) {
+            connection.release();
+        }
    }
 }

--- a/inventory-server/scripts/metrics/financial-metrics.js
+++ b/inventory-server/scripts/metrics/financial-metrics.js
@@ -1,18 +1,32 @@
-const { outputProgress } = require('./utils/progress');
+const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');

-async function calculateFinancialMetrics(startTime, totalProducts, processedCount) {
+async function calculateFinancialMetrics(startTime, totalProducts, processedCount, isCancelled = false) {
    const connection = await getConnection();
    try {
+        if (isCancelled) {
+            outputProgress({
+                status: 'cancelled',
+                operation: 'Financial metrics calculation cancelled',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: null,
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
+            return processedCount;
+        }
+
        outputProgress({
            status: 'running',
-            operation: 'Calculating financial metrics',
-            current: Math.floor(totalProducts * 0.6),
+            operation: 'Starting financial metrics calculation',
+            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.6), totalProducts),
-            rate: calculateRate(startTime, Math.floor(totalProducts * 0.6)),
-            percentage: '60'
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
        });

        // Calculate financial metrics with optimized query
@@ -48,6 +62,20 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
                END
        `);

+        processedCount = Math.floor(totalProducts * 0.65);
+        outputProgress({
+            status: 'running',
+            operation: 'Base financial metrics calculated, updating time aggregates',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Update time-based aggregates with optimized query
        await connection.query(`
            WITH monthly_financials AS (
@@ -78,9 +106,26 @@ async function calculateFinancialMetrics(startTime, totalProducts, processedCoun
                END
        `);

-        return Math.floor(totalProducts * 0.7);
+        processedCount = Math.floor(totalProducts * 0.70);
+        outputProgress({
+            status: 'running',
+            operation: 'Time-based aggregates updated',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        return processedCount;
+    } catch (error) {
+        logError(error, 'Error calculating financial metrics');
+        throw error;
    } finally {
-        connection.release();
+        if (connection) {
+            connection.release();
+        }
    }
 }

--- a/inventory-server/scripts/metrics/product-metrics.js
+++ b/inventory-server/scripts/metrics/product-metrics.js
@@ -1,4 +1,4 @@
-const { outputProgress, logError } = require('./utils/progress');
+const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');

 // Helper function to handle NaN and undefined values
@@ -9,24 +9,38 @@ function sanitizeValue(value) {
    return value;
 }

-async function calculateProductMetrics(startTime, totalProducts, processedCount = 0) {
+async function calculateProductMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
    const connection = await getConnection();
    try {
        // Skip flags are inherited from the parent scope
        const SKIP_PRODUCT_BASE_METRICS = 0;
-        const SKIP_PRODUCT_TIME_AGGREGATES =0;
+        const SKIP_PRODUCT_TIME_AGGREGATES = 0;
+
+        if (isCancelled) {
+            outputProgress({
+                status: 'cancelled',
+                operation: 'Product metrics calculation cancelled',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: null,
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
+            return processedCount;
+        }

        // Calculate base product metrics
        if (!SKIP_PRODUCT_BASE_METRICS) {
            outputProgress({
                status: 'running',
-                operation: 'Calculating base product metrics',
-                current: Math.floor(totalProducts * 0.2),
+                operation: 'Starting base product metrics calculation',
+                current: processedCount,
                total: totalProducts,
                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.2), totalProducts),
-                rate: calculateRate(startTime, Math.floor(totalProducts * 0.2)),
-                percentage: '20'
+                remaining: estimateRemaining(startTime, processedCount, totalProducts),
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
            });

            // Calculate base metrics
@@ -72,8 +86,17 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
            `);

            processedCount = Math.floor(totalProducts * 0.4);
+            outputProgress({
+                status: 'running',
+                operation: 'Base product metrics calculated',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: estimateRemaining(startTime, processedCount, totalProducts),
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
        } else {
-            console.log('Skipping base product metrics calculation');
            processedCount = Math.floor(totalProducts * 0.4);
            outputProgress({
                status: 'running',
@@ -83,21 +106,23 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                elapsed: formatElapsedTime(startTime),
                remaining: estimateRemaining(startTime, processedCount, totalProducts),
                rate: calculateRate(startTime, processedCount),
-                percentage: '40'
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
            });
        }

+        if (isCancelled) return processedCount;
+
        // Calculate product time aggregates
        if (!SKIP_PRODUCT_TIME_AGGREGATES) {
            outputProgress({
                status: 'running',
-                operation: 'Calculating product time aggregates',
-                current: Math.floor(totalProducts * 0.4),
+                operation: 'Starting product time aggregates calculation',
+                current: processedCount,
                total: totalProducts,
                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.4), totalProducts),
-                rate: calculateRate(startTime, Math.floor(totalProducts * 0.4)),
-                percentage: '40'
+                remaining: estimateRemaining(startTime, processedCount, totalProducts),
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
            });

            // Calculate time-based aggregates
@@ -151,8 +176,17 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
            `);

            processedCount = Math.floor(totalProducts * 0.6);
+            outputProgress({
+                status: 'running',
+                operation: 'Product time aggregates calculated',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: estimateRemaining(startTime, processedCount, totalProducts),
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
        } else {
-            console.log('Skipping product time aggregates calculation');
            processedCount = Math.floor(totalProducts * 0.6);
            outputProgress({
                status: 'running',
@@ -162,11 +196,14 @@ async function calculateProductMetrics(startTime, totalProducts, processedCount
                elapsed: formatElapsedTime(startTime),
                remaining: estimateRemaining(startTime, processedCount, totalProducts),
                rate: calculateRate(startTime, processedCount),
-                percentage: '60'
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
            });
        }

        return processedCount;
+    } catch (error) {
+        logError(error, 'Error calculating product metrics');
+        throw error;
    } finally {
        if (connection) {
            connection.release();
--- a/inventory-server/scripts/metrics/sales-forecasts.js
+++ b/inventory-server/scripts/metrics/sales-forecasts.js
@@ -1,18 +1,32 @@
-const { outputProgress } = require('./utils/progress');
+const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');

-async function calculateSalesForecasts(startTime, totalProducts, processedCount) {
+async function calculateSalesForecasts(startTime, totalProducts, processedCount, isCancelled = false) {
    const connection = await getConnection();
    try {
+        if (isCancelled) {
+            outputProgress({
+                status: 'cancelled',
+                operation: 'Sales forecasts calculation cancelled',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: null,
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
+            return processedCount;
+        }
+
        outputProgress({
            status: 'running',
-            operation: 'Calculating sales forecasts',
-            current: Math.floor(totalProducts * 0.98),
+            operation: 'Starting sales forecasts calculation',
+            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.98), totalProducts),
-            rate: calculateRate(startTime, Math.floor(totalProducts * 0.98)),
-            percentage: '98'
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
        });

        // First, create a temporary table for forecast dates
@@ -42,6 +56,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount)
            ) numbers
        `);

+        processedCount = Math.floor(totalProducts * 0.92);
+        outputProgress({
+            status: 'running',
+            operation: 'Forecast dates prepared, calculating daily sales stats',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Create temporary table for daily sales stats
        await connection.query(`
            CREATE TEMPORARY TABLE IF NOT EXISTS temp_daily_sales AS
@@ -57,6 +85,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount)
            GROUP BY o.pid, DAYOFWEEK(o.date)
        `);

+        processedCount = Math.floor(totalProducts * 0.94);
+        outputProgress({
+            status: 'running',
+            operation: 'Daily sales stats calculated, preparing product stats',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Create temporary table for product stats
        await connection.query(`
            CREATE TEMPORARY TABLE IF NOT EXISTS temp_product_stats AS
@@ -68,6 +110,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount)
            GROUP BY pid
        `);

+        processedCount = Math.floor(totalProducts * 0.96);
+        outputProgress({
+            status: 'running',
+            operation: 'Product stats prepared, calculating product-level forecasts',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Calculate product-level forecasts
        await connection.query(`
            INSERT INTO sales_forecasts (
@@ -116,6 +172,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount)
                last_calculated_at = NOW()
        `);

+        processedCount = Math.floor(totalProducts * 0.98);
+        outputProgress({
+            status: 'running',
+            operation: 'Product forecasts calculated, preparing category stats',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Create temporary table for category stats
        await connection.query(`
            CREATE TEMPORARY TABLE IF NOT EXISTS temp_category_sales AS
@@ -142,6 +212,20 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount)
            GROUP BY cat_id
        `);

+        processedCount = Math.floor(totalProducts * 0.99);
+        outputProgress({
+            status: 'running',
+            operation: 'Category stats prepared, calculating category-level forecasts',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Calculate category-level forecasts
        await connection.query(`
            INSERT INTO category_forecasts (
@@ -199,9 +283,26 @@ async function calculateSalesForecasts(startTime, totalProducts, processedCount)
            DROP TEMPORARY TABLE IF EXISTS temp_category_stats;
        `);

-        return Math.floor(totalProducts * 1.0);
+        processedCount = Math.floor(totalProducts * 1.0);
+        outputProgress({
+            status: 'running',
+            operation: 'Category forecasts calculated and temporary tables cleaned up',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        return processedCount;
+    } catch (error) {
+        logError(error, 'Error calculating sales forecasts');
+        throw error;
    } finally {
-        connection.release();
+        if (connection) {
+            connection.release();
+        }
    }
 }

--- a/inventory-server/scripts/metrics/time-aggregates.js
+++ b/inventory-server/scripts/metrics/time-aggregates.js
@@ -1,18 +1,32 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate } = require('./utils/progress');
+const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');

-async function calculateTimeAggregates(startTime, totalProducts, processedCount) {
+async function calculateTimeAggregates(startTime, totalProducts, processedCount, isCancelled = false) {
    const connection = await getConnection();
    try {
+        if (isCancelled) {
+            outputProgress({
+                status: 'cancelled',
+                operation: 'Time aggregates calculation cancelled',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: null,
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
+            return processedCount;
+        }
+
        outputProgress({
            status: 'running',
-            operation: 'Calculating time aggregates',
-            current: Math.floor(totalProducts * 0.95),
+            operation: 'Starting time aggregates calculation',
+            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.95), totalProducts),
-            rate: calculateRate(startTime, Math.floor(totalProducts * 0.95)),
-            percentage: '95'
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
        });

        // Initial insert of time-based aggregates
@@ -109,6 +123,20 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount)
                profit_margin = VALUES(profit_margin)
        `);

+        processedCount = Math.floor(totalProducts * 0.60);
+        outputProgress({
+            status: 'running',
+            operation: 'Base time aggregates calculated, updating financial metrics',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        if (isCancelled) return processedCount;
+
        // Update with financial metrics
        await connection.query(`
            UPDATE product_time_aggregates pta
@@ -136,7 +164,22 @@ async function calculateTimeAggregates(startTime, totalProducts, processedCount)
                END
        `);

-        return Math.floor(totalProducts * 0.65);
+        processedCount = Math.floor(totalProducts * 0.65);
+        outputProgress({
+            status: 'running',
+            operation: 'Financial metrics updated',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        return processedCount;
+    } catch (error) {
+        logError(error, 'Error calculating time aggregates');
+        throw error;
    } finally {
        if (connection) {
            connection.release();
--- a/inventory-server/scripts/metrics/vendor-metrics.js
+++ b/inventory-server/scripts/metrics/vendor-metrics.js
@@ -1,18 +1,32 @@
-const { outputProgress } = require('./utils/progress');
+const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
 const { getConnection } = require('./utils/db');

-async function calculateVendorMetrics(startTime, totalProducts, processedCount) {
+async function calculateVendorMetrics(startTime, totalProducts, processedCount, isCancelled = false) {
    const connection = await getConnection();
    try {
+        if (isCancelled) {
+            outputProgress({
+                status: 'cancelled',
+                operation: 'Vendor metrics calculation cancelled',
+                current: processedCount,
+                total: totalProducts,
+                elapsed: formatElapsedTime(startTime),
+                remaining: null,
+                rate: calculateRate(startTime, processedCount),
+                percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+            });
+            return processedCount;
+        }
+
        outputProgress({
            status: 'running',
-            operation: 'Ensuring vendors exist in vendor_details',
-            current: Math.floor(totalProducts * 0.7),
+            operation: 'Starting vendor metrics calculation',
+            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.7), totalProducts),
-            rate: calculateRate(startTime, Math.floor(totalProducts * 0.7)),
-            percentage: '70'
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
        });

        // First ensure all vendors exist in vendor_details
@@ -27,17 +41,20 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount)
            WHERE vendor IS NOT NULL
        `);

+        processedCount = Math.floor(totalProducts * 0.8);
        outputProgress({
            status: 'running',
-            operation: 'Calculating vendor metrics',
-            current: Math.floor(totalProducts * 0.8),
+            operation: 'Vendor details updated, calculating metrics',
+            current: processedCount,
            total: totalProducts,
            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, Math.floor(totalProducts * 0.8), totalProducts),
-            rate: calculateRate(startTime, Math.floor(totalProducts * 0.8)),
-            percentage: '80'
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
        });

+        if (isCancelled) return processedCount;
+
        // Now calculate vendor metrics
        await connection.query(`
            INSERT INTO vendor_metrics (
@@ -130,9 +147,26 @@ async function calculateVendorMetrics(startTime, totalProducts, processedCount)
                last_calculated_at = VALUES(last_calculated_at)
        `);

-        return Math.floor(totalProducts * 0.9);
+        processedCount = Math.floor(totalProducts * 0.9);
+        outputProgress({
+            status: 'running',
+            operation: 'Vendor metrics calculated',
+            current: processedCount,
+            total: totalProducts,
+            elapsed: formatElapsedTime(startTime),
+            remaining: estimateRemaining(startTime, processedCount, totalProducts),
+            rate: calculateRate(startTime, processedCount),
+            percentage: ((processedCount / totalProducts) * 100).toFixed(1)
+        });
+
+        return processedCount;
+    } catch (error) {
+        logError(error, 'Error calculating vendor metrics');
+        throw error;
    } finally {
-        connection.release();
+        if (connection) {
+            connection.release();
+        }
    }
 }