Attempted improvements to validation to make the validation step table more responsive

ecosystem.config.js

@@ -1,222 +0,0 @@
-// ecosystem.config.js
-const path = require('path');
-const dotenv = require('dotenv');
-
-// Load environment variables safely with error handling
-const loadEnvFile = (envPath) => {
-  try {
-    console.log('Loading env from:', envPath);
-    const result = dotenv.config({ path: envPath });
-    if (result.error) {
-      console.warn(`Warning: .env file not found or invalid at ${envPath}:`, result.error.message);
-      return {};
-    }
-    console.log('Env variables loaded from', envPath, ':', Object.keys(result.parsed || {}));
-    return result.parsed || {};
-  } catch (error) {
-    console.warn(`Warning: Error loading .env file at ${envPath}:`, error.message);
-    return {};
-  }
-}
-
-// Load environment variables for each server
-const authEnv = loadEnvFile(path.resolve(__dirname, 'dashboard/auth-server/.env'));
-const aircallEnv = loadEnvFile(path.resolve(__dirname, 'dashboard/aircall-server/.env'));
-const klaviyoEnv = loadEnvFile(path.resolve(__dirname, 'dashboard/klaviyo-server/.env'));
-const metaEnv = loadEnvFile(path.resolve(__dirname, 'dashboard/meta-server/.env'));
-const googleAnalyticsEnv = require('dotenv').config({ 
-  path: path.resolve(__dirname, 'dashboard/google-server/.env') 
-}).parsed || {};
-const typeformEnv = loadEnvFile(path.resolve(__dirname, 'dashboard/typeform-server/.env'));
-const inventoryEnv = loadEnvFile(path.resolve(__dirname, 'inventory/.env'));
-
-// Common log settings for all apps
-const logSettings = {
-  log_rotate: true,
-  max_size: '10M',
-  retain: '10',
-  log_date_format: 'YYYY-MM-DD HH:mm:ss'
-};
-
-// Common app settings
-const commonSettings = {
-  instances: 1,
-  exec_mode: 'fork',
-  autorestart: true,
-  watch: false,
-  max_memory_restart: '1G',
-  time: true,
-  ...logSettings,
-  ignore_watch: [
-    'node_modules',
-    'logs',
-    '.git',
-    '*.log'
-  ],
-  min_uptime: 5000,
-  max_restarts: 5,
-  restart_delay: 4000,
-  listen_timeout: 50000,
-  kill_timeout: 5000,
-  node_args: '--max-old-space-size=1536'
-};
-
-module.exports = {
-  apps: [
-    {
-      ...commonSettings,
-      name: 'auth-server',
-      script: './dashboard/auth-server/index.js',
-      env: {
-        NODE_ENV: 'production',
-        PORT: 3003,
-        ...authEnv
-      },
-      error_file: 'dashboard/auth-server/logs/pm2/err.log',
-      out_file: 'dashboard/auth-server/logs/pm2/out.log',
-      log_file: 'dashboard/auth-server/logs/pm2/combined.log',
-      env_production: {
-        NODE_ENV: 'production',
-        PORT: 3003
-      },
-      env_development: {
-        NODE_ENV: 'development',
-        PORT: 3003
-      }
-    },
-    {
-      ...commonSettings,
-      name: 'aircall-server',
-      script: './dashboard/aircall-server/server.js',
-      env: {
-        NODE_ENV: 'production',
-        AIRCALL_PORT: 3002,
-        ...aircallEnv
-      },
-      error_file: 'dashboard/aircall-server/logs/pm2/err.log',
-      out_file: 'dashboard/aircall-server/logs/pm2/out.log',
-      log_file: 'dashboard/aircall-server/logs/pm2/combined.log',
-      env_production: {
-        NODE_ENV: 'production',
-        AIRCALL_PORT: 3002
-      }
-    },
-    {
-      ...commonSettings,
-      name: 'klaviyo-server',
-      script: './dashboard/klaviyo-server/server.js',
-      env: {
-        NODE_ENV: 'production',
-        KLAVIYO_PORT: 3004,
-        ...klaviyoEnv
-      },
-      error_file: 'dashboard/klaviyo-server/logs/pm2/err.log',
-      out_file: 'dashboard/klaviyo-server/logs/pm2/out.log',
-      log_file: 'dashboard/klaviyo-server/logs/pm2/combined.log',
-      env_production: {
-        NODE_ENV: 'production',
-        KLAVIYO_PORT: 3004
-      }
-    },
-    {
-      ...commonSettings,
-      name: 'meta-server',
-      script: './dashboard/meta-server/server.js',
-      env: {
-        NODE_ENV: 'production',
-        PORT: 3005,
-        ...metaEnv
-      },
-      error_file: 'dashboard/meta-server/logs/pm2/err.log',
-      out_file: 'dashboard/meta-server/logs/pm2/out.log',
-      log_file: 'dashboard/meta-server/logs/pm2/combined.log',
-      env_production: {
-        NODE_ENV: 'production',
-        PORT: 3005
-      }
-    },
-    {
-      name: "gorgias-server",
-      script: "./dashboard/gorgias-server/server.js",
-      env: {
-        NODE_ENV: "development",
-        PORT: 3006
-      },
-      env_production: {
-        NODE_ENV: "production",
-        PORT: 3006
-      },
-      error_file: "dashboard/logs/gorgias-server-error.log",
-      out_file: "dashboard/logs/gorgias-server-out.log",
-      log_file: "dashboard/logs/gorgias-server-combined.log",
-      time: true
-    },
-    {
-      ...commonSettings,
-      name: 'google-server',
-      script: path.resolve(__dirname, 'dashboard/google-server/server.js'),
-      watch: false,
-      env: {
-        NODE_ENV: 'production',
-        GOOGLE_ANALYTICS_PORT: 3007,
-        ...googleAnalyticsEnv
-      },
-      error_file: path.resolve(__dirname, 'dashboard/google-server/logs/pm2/err.log'),
-      out_file: path.resolve(__dirname, 'dashboard/google-server/logs/pm2/out.log'),
-      log_file: path.resolve(__dirname, 'dashboard/google-server/logs/pm2/combined.log'),
-      env_production: {
-        NODE_ENV: 'production',
-        GOOGLE_ANALYTICS_PORT: 3007
-      }
-    },
-    {
-      ...commonSettings,
-      name: 'typeform-server',
-      script: './dashboard/typeform-server/server.js',
-      env: {
-        NODE_ENV: 'production',
-        TYPEFORM_PORT: 3008,
-        ...typeformEnv
-      },
-      error_file: 'dashboard/typeform-server/logs/pm2/err.log',
-      out_file: 'dashboard/typeform-server/logs/pm2/out.log',
-      log_file: 'dashboard/typeform-server/logs/pm2/combined.log',
-      env_production: {
-        NODE_ENV: 'production',
-        TYPEFORM_PORT: 3008
-      }
-    },
-    {
-      ...commonSettings,
-      name: 'inventory-server',
-      script: './inventory/src/server.js',
-      env: {
-        NODE_ENV: 'production',
-        PORT: 3010,
-        ...inventoryEnv
-      },
-      error_file: 'inventory/logs/pm2/err.log',
-      out_file: 'inventory/logs/pm2/out.log',
-      log_file: 'inventory/logs/pm2/combined.log',
-      env_production: {
-        NODE_ENV: 'production',
-        PORT: 3010,
-        ...inventoryEnv
-      }
-    },
-    {
-      ...commonSettings,
-      name: 'new-auth-server',
-      script: './inventory-server/auth/server.js',
-      env: {
-        NODE_ENV: 'production',
-        AUTH_PORT: 3011,
-        ...inventoryEnv,
-        JWT_SECRET: process.env.JWT_SECRET
-      },
-      error_file: 'inventory-server/auth/logs/pm2/err.log',
-      out_file: 'inventory-server/auth/logs/pm2/out.log',
-      log_file: 'inventory-server/auth/logs/pm2/combined.log'
-    }
-  ]
-};

inventory-server/dashboard/.env-future

@@ -0,0 +1,20 @@
+# Caching Server Configuration
+PORT=3010
+NODE_ENV=production
+
+# Database Configuration
+MONGODB_URI=mongodb://dashboard_user:WDRFWiGXEeaC6aAyUKuT@localhost:27017/dashboard?authSource=dashboard
+REDIS_URL=redis://:Wgj32YXxxVLtPZoVzUnP@localhost:6379
+
+# Gorgias
+GORGIAS_API_USERNAME=matt@acherryontop.com
+GORGIAS_API_PASSWORD=d2ed0d23d2a7bf11a633a12fb260769f4e4a970d440693e7d64b8d2223fa6503
+
+# GA4 credentials
+GA_PROPERTY_ID=281045851
+GOOGLE_APPLICATION_CREDENTIALS_JSON={"type": "service_account","project_id": "acot-stats","private_key_id": "259d1fd9864efbfa38b8ba02fdd74dc008ace3c5","private_key": "-----BEGIN PRIVATE KEY-----\nMIIEvQIBADANBgkqhkiG9w0BAQEFAASCBKcwggSjAgEAAoIBAQC5Y6foai8WF98k\nIA0yLn94Y3lmDYlyvI9xL2YqSZSyvgK35wdWRTIaEvHKdiUWuYi3ZPdkYmz1OYiV\njVfR2g+mFpA7MI/JMwyGWwjnV4WW2q6INfgi/PvHlbP3LyyQo0B8CvAY0CHqrpDs\nlJQhAkqmteU24dqcdZoV3vM8JMsDiXm44DqwXsEfWibKv4i0mWNkwiEQr0yImHwb\nbjgclwVLLi5kdM2+49PXr47LCODdL+xmX0uSdgSG6XYqEIVsEOXIUJKzqUe036b/\nEFQ0BxWdJBWs/MYOapn/NNv+Mts+am2ipUuIcgPbOut4xa2Fkky93WnJf0tB+VJP\njFnyZJhdAgMBAAECggEAC980Cp/4zvSNZMNWr6l8ST8u2thavnRmcoGYtx7ffQjK\nT3Dl2TefgJLzqpr2lLt3OVint7p5LsUAmE8lBLpu+RxbH9HkIKbPvQTfD5gyZQQx\nBruqCGzkn2st9fzZNj6gwQYe9P/TGYkUnR8wqI0nLwDZTQful3QNKixiWC4lAAoK\nqdd6H++pqjVUiTqgFwFD3zBAhO0Lp8m/c5vTRT5kxi0wCTK66FaaGLr2OwZHcohp\nE8rEcTZ5kaJzBwqEz522R6ufQqN1Swoq4K6Ul3aAc59539VdrLNs++/eRH38MMVq\n5UTwBrH+zIkXIYv4mtGpR1NWGO2bZ652GzGXNEXcQQKBgQD9WsMmioIeWR9P9I0r\nIY+yyxz1EyscutUtnOtROT36OxokrzQaAKDz/OC3jVnhZSkzG6RcmmK/AJrcU+2m\n1L4mZGfF3DdeTqtK/KkNzGs9yRPDkbb/MF0wgtcvfE8tJH/suiDJKQNsjeaQIQW3\n4NvDxs0w60m9r9tk1CQau94ovQKBgQC7UzeA0mDSxIB5agGbvnzaJJTvAFvnCvhz\nu3ZakTlNecAHu4eOMc0+OCHFPLJlLL4b0oraOxZIszX9BTlgcstBmTUk03TibNsS\nsDiImHFC4hE5x6EPdifnkVFUXPMZ/eF0mHUPBEn41ipw1hoLfl6W+aYW9QUxBMWA\nzdMH4rg4IQKBgQCFcMaUiCNchKhfXnj0HKspCp3n3v64FReu/JVcpH+mSnbMl5Mj\nlu0vVSOuyb5rXvLCPm7lb1NPMqxeG75yPl8grYWSyxhGjbzetBD+eYqKclv8h8UQ\nx5JtuJxKIHk7V5whPS+DhByPknW7uAjg/ogBp7XvbB3c0MEHbEzP3991KQKBgC+a\n610Kmd6WX4v7e6Mn2rTZXRwL/E8QA6nttxs3Etf0m++bIczqLR2lyDdGwJNjtoB9\nlhn1sCkTmiHOBRHUuoDWPaI5NtggD+CE9ikIjKgRqY0EhZLXVTbNQFzvLjypv3UR\nFZaWYXIigzCfyIipOcKmeSYWaJZXfxXHuNylKmnhAoGAFa84AuOOGUr+pEvtUzIr\nvBKu1mnQbbsLEhgf3Tw88K3sO5OlguAwBEvD4eitj/aU5u2vJJhFa67cuERLsZru\n0sjtQwP6CJbWF4uaH0Hso4KQvnwl4BfdKwUncqoKtHrQiuGMvr5P5G941+Ax8brE\nJlC2e/RPUQKxScpK3nNK9mc=\n-----END PRIVATE KEY-----\n","client_email": "matt-dashboard@acot-stats.iam.gserviceaccount.com","client_id": "106112731322970982546","auth_uri": "https://accounts.google.com/o/oauth2/auth","token_uri": "https://oauth2.googleapis.com/token","auth_provider_x509_cert_url": "https://www.googleapis.com/oauth2/v1/certs","client_x509_cert_url": "https://www.googleapis.com/robot/v1/metadata/x509/matt-dashboard%40acot-stats.iam.gserviceaccount.com","universe_domain": "googleapis.com"}
+
+# Logging
+LOG_LEVEL=info
+LOG_MAX_SIZE=10m
+LOG_MAX_FILES=5

inventory-server/dashboard/acot-server/README.md

@@ -0,0 +1,205 @@
+# ACOT Server
+
+This server replaces the Klaviyo integration with direct database queries to the production MySQL database via SSH tunnel. It provides seamless API compatibility for all frontend components without requiring any frontend changes.
+
+## Setup
+
+1. **Environment Variables**: Copy `.env.example` to `.env` and configure:
+   ```
+   DB_HOST=localhost
+   DB_PORT=3306
+   DB_USER=your_db_user
+   DB_PASSWORD=your_db_password
+   DB_NAME=your_db_name
+   PORT=3007
+   NODE_ENV=development
+   ```
+
+2. **SSH Tunnel**: Ensure your SSH tunnel to the production database is running on localhost:3306.
+
+3. **Install Dependencies**:
+   ```bash
+   npm install
+   ```
+
+4. **Start Server**:
+   ```bash
+   npm start
+   ```
+
+## API Endpoints
+
+All endpoints provide exact API compatibility with the previous Klaviyo implementation:
+
+### Main Statistics
+- `GET /api/acot/events/stats` - Complete statistics dashboard data
+  - Query params: `timeRange` (today, yesterday, thisWeek, lastWeek, thisMonth, lastMonth, last7days, last30days, last90days) or `startDate`/`endDate` for custom ranges
+  - Returns: Revenue, orders, AOV, shipping data, order types, brands/categories, refunds, cancellations, best day, peak hour, order ranges, period progress, projections
+
+### Daily Details
+- `GET /api/acot/events/stats/details` - Daily breakdown with previous period comparisons
+  - Query params: `timeRange`, `metric` (revenue, orders, average_order, etc.), `daily=true`
+  - Returns: Array of daily data points with trend comparisons
+
+### Products
+- `GET /api/acot/events/products` - Top products with sales data
+  - Query params: `timeRange`
+  - Returns: Product list with images, sales quantities, revenue, and order counts
+
+### Projections
+- `GET /api/acot/events/projection` - Smart revenue projections for incomplete periods
+  - Query params: `timeRange`
+  - Returns: Projected revenue with confidence levels based on historical patterns
+
+### Health Check
+- `GET /api/acot/test` - Server health and database connectivity test
+
+## Database Schema
+
+The server queries the following main tables:
+
+### Orders (`_order`)
+- **Key fields**: `order_id`, `date_placed`, `summary_total`, `order_status`, `ship_method_selected`, `stats_waiting_preorder`
+- **Valid orders**: `order_status > 15`
+- **Cancelled orders**: `order_status = 15`
+- **Shipped orders**: `order_status IN (100, 92)`
+- **Pre-orders**: `stats_waiting_preorder > 0`
+- **Local pickup**: `ship_method_selected = 'localpickup'`
+- **On-hold orders**: `ship_method_selected = 'holdit'`
+
+### Order Items (`order_items`)
+- **Fields**: `order_id`, `prod_pid`, `qty_ordered`, `prod_price`
+- **Purpose**: Links orders to products for detailed analysis
+
+### Products (`products`)
+- **Fields**: `pid`, `description` (product name), `company`
+- **Purpose**: Product information and brand data
+
+### Product Images (`product_images`)
+- **Fields**: `pid`, `iid`, `order` (priority)
+- **Primary image**: `order = 255` (highest priority)
+- **Image URL generation**: `https://sbing.com/i/products/0000/{prefix}/{pid}-{type}-{iid}.jpg`
+
+### Payments (`order_payment`)
+- **Refunds**: `payment_amount < 0`
+- **Purpose**: Track refund amounts and counts
+
+## Business Logic
+
+### Time Handling
+- **Timezone**: All calculations in UTC-5 (Eastern Time)
+- **Business Day**: 1 AM - 12:59 AM Eastern (25-hour business day)
+- **Format**: MySQL DATETIME format (YYYY-MM-DD HH:MM:SS)
+- **Period Boundaries**: Calculated using `timeUtils.js` for consistent time range handling
+
+### Order Processing
+- **Revenue Calculation**: Only includes orders with `order_status > 15`
+- **Order Types**:
+  - Pre-orders: `stats_waiting_preorder > 0`
+  - Local pickup: `ship_method_selected = 'localpickup'`
+  - On-hold: `ship_method_selected = 'holdit'`
+- **Shipping Methods**: Mapped to friendly names (e.g., `usps_ground_advantage` → "USPS Ground Advantage")
+
+### Projections
+- **Period Progress**: Calculated based on current time within the selected period
+- **Simple Projection**: Linear extrapolation based on current progress
+- **Smart Projection**: Uses historical data patterns for more accurate forecasting
+- **Confidence Levels**: Based on data consistency and historical accuracy
+
+### Image URL Generation
+- **Pattern**: `https://sbing.com/i/products/0000/{prefix}/{pid}-{type}-{iid}.jpg`
+- **Prefix**: First 2 digits of product ID
+- **Type**: "main" for primary images
+- **Fallback**: Uses primary image (order=255) when available
+
+## Frontend Integration
+
+### Service Layer (`services/acotService.js`)
+- **Purpose**: Replaces direct Klaviyo API calls with acot-server calls
+- **Methods**: `getStats()`, `getStatsDetails()`, `getProducts()`, `getProjection()`
+- **Logging**: Axios interceptors for request/response logging
+- **Environment**: Automatic URL handling (proxy in dev, direct in production)
+
+### Component Updates
+All 5 main components updated to use `acotService`:
+- **StatCards.jsx**: Main dashboard statistics
+- **MiniStatCards.jsx**: Compact statistics view
+- **SalesChart.jsx**: Revenue and order trends
+- **MiniSalesChart.jsx**: Compact chart view
+- **ProductGrid.jsx**: Top products table
+
+### Proxy Configuration (`vite.config.js`)
+```javascript
+'/api/acot': {
+  target: 'http://localhost:3007',
+  changeOrigin: true,
+  secure: false
+}
+```
+
+## Key Features
+
+### Complete Business Intelligence
+- **Revenue Analytics**: Total revenue, trends, projections
+- **Order Analysis**: Counts, types, status tracking
+- **Product Performance**: Top sellers, revenue contribution
+- **Shipping Intelligence**: Methods, locations, distribution
+- **Customer Insights**: Order value ranges, patterns
+- **Operational Metrics**: Refunds, cancellations, peak hours
+
+### Performance Optimizations
+- **Connection Pooling**: Efficient database connection management
+- **Query Optimization**: Indexed queries with proper WHERE clauses
+- **Caching Strategy**: Frontend caching for detail views
+- **Batch Processing**: Efficient data aggregation
+
+### Error Handling
+- **Database Connectivity**: Graceful handling of connection issues
+- **Query Failures**: Detailed error logging and user-friendly messages
+- **Data Validation**: Input sanitization and validation
+- **Fallback Mechanisms**: Default values for missing data
+
+## Simplified Elements
+
+Due to database complexity, some features are simplified:
+- **Brands**: Shows "Various Brands" (companies table structure complex)
+- **Categories**: Shows "General" (category relationships complex)
+
+These can be enhanced in future iterations with proper category mapping.
+
+## Testing
+
+Test the server functionality:
+
+```bash
+# Health check
+curl http://localhost:3007/api/acot/test
+
+# Today's stats
+curl http://localhost:3007/api/acot/events/stats?timeRange=today
+
+# Last 30 days with details
+curl http://localhost:3007/api/acot/events/stats/details?timeRange=last30days&daily=true
+
+# Top products
+curl http://localhost:3007/api/acot/events/products?timeRange=thisWeek
+
+# Revenue projection
+curl http://localhost:3007/api/acot/events/projection?timeRange=today
+```
+
+## Development Notes
+
+- **No Frontend Changes**: Complete drop-in replacement for Klaviyo
+- **API Compatibility**: Maintains exact response structure
+- **Business Logic**: Implements all complex e-commerce calculations
+- **Scalability**: Designed for production workloads
+- **Maintainability**: Well-documented code with clear separation of concerns
+
+## Future Enhancements
+
+- Enhanced category and brand mapping
+- Real-time notifications for significant events
+- Advanced analytics and forecasting
+- Customer segmentation analysis
+- Inventory integration 

inventory-server/dashboard/acot-server/db/connection.js

@@ -0,0 +1,297 @@
+const { Client } = require('ssh2');
+const mysql = require('mysql2/promise');
+const fs = require('fs');
+
+// Connection pool configuration
+const connectionPool = {
+  connections: [],
+  maxConnections: 20,
+  currentConnections: 0,
+  pendingRequests: [],
+  // Cache for query results (key: query string, value: {data, timestamp})
+  queryCache: new Map(),
+  // Cache duration for different query types in milliseconds
+  cacheDuration: {
+    'stats': 60 * 1000,              // 1 minute for stats
+    'products': 5 * 60 * 1000,       // 5 minutes for products
+    'orders': 60 * 1000,             // 1 minute for orders
+    'default': 60 * 1000             // 1 minute default
+  },
+  // Circuit breaker state
+  circuitBreaker: {
+    failures: 0,
+    lastFailure: 0,
+    isOpen: false,
+    threshold: 5,
+    timeout: 30000 // 30 seconds
+  }
+};
+
+/**
+ * Get a database connection from the pool
+ * @returns {Promise<{connection: object, release: function}>} The database connection and release function
+ */
+async function getDbConnection() {
+  return new Promise(async (resolve, reject) => {
+    // Check circuit breaker
+    const now = Date.now();
+    if (connectionPool.circuitBreaker.isOpen) {
+      if (now - connectionPool.circuitBreaker.lastFailure > connectionPool.circuitBreaker.timeout) {
+        // Reset circuit breaker
+        connectionPool.circuitBreaker.isOpen = false;
+        connectionPool.circuitBreaker.failures = 0;
+        console.log('Circuit breaker reset');
+      } else {
+        reject(new Error('Circuit breaker is open - too many connection failures'));
+        return;
+      }
+    }
+    
+    // Check if there's an available connection in the pool
+    if (connectionPool.connections.length > 0) {
+      const conn = connectionPool.connections.pop();
+      console.log(`Using pooled connection. Pool size: ${connectionPool.connections.length}`);
+      resolve({
+        connection: conn.connection,
+        release: () => releaseConnection(conn)
+      });
+      return;
+    }
+    
+    // If we haven't reached max connections, create a new one
+    if (connectionPool.currentConnections < connectionPool.maxConnections) {
+      try {
+        console.log(`Creating new connection. Current: ${connectionPool.currentConnections}/${connectionPool.maxConnections}`);
+        connectionPool.currentConnections++;
+        
+        const tunnel = await setupSshTunnel();
+        const { ssh, stream, dbConfig } = tunnel;
+        
+        const connection = await mysql.createConnection({
+          ...dbConfig,
+          stream
+        });
+        
+        const conn = { ssh, connection, inUse: true, created: Date.now() };
+        
+        console.log('Database connection established');
+        
+        // Reset circuit breaker on successful connection
+        if (connectionPool.circuitBreaker.failures > 0) {
+          connectionPool.circuitBreaker.failures = 0;
+          connectionPool.circuitBreaker.isOpen = false;
+        }
+        
+        resolve({
+          connection: conn.connection,
+          release: () => releaseConnection(conn)
+        });
+      } catch (error) {
+        connectionPool.currentConnections--;
+        
+        // Track circuit breaker failures
+        connectionPool.circuitBreaker.failures++;
+        connectionPool.circuitBreaker.lastFailure = Date.now();
+        
+        if (connectionPool.circuitBreaker.failures >= connectionPool.circuitBreaker.threshold) {
+          connectionPool.circuitBreaker.isOpen = true;
+          console.log(`Circuit breaker opened after ${connectionPool.circuitBreaker.failures} failures`);
+        }
+        
+        reject(error);
+      }
+      return;
+    }
+    
+    // Pool is full, queue the request with timeout
+    console.log('Connection pool full, queuing request...');
+    const timeoutId = setTimeout(() => {
+      // Remove from queue if still there
+      const index = connectionPool.pendingRequests.findIndex(req => req.resolve === resolve);
+      if (index !== -1) {
+        connectionPool.pendingRequests.splice(index, 1);
+        reject(new Error('Connection pool queue timeout after 15 seconds'));
+      }
+          }, 15000);
+    
+    connectionPool.pendingRequests.push({ 
+      resolve, 
+      reject, 
+      timeoutId,
+      timestamp: Date.now()
+    });
+  });
+}
+
+/**
+ * Release a connection back to the pool
+ */
+function releaseConnection(conn) {
+  conn.inUse = false;
+  
+  // Check if there are pending requests
+  if (connectionPool.pendingRequests.length > 0) {
+    const { resolve, timeoutId } = connectionPool.pendingRequests.shift();
+    
+    // Clear the timeout since we're serving the request
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+    
+    conn.inUse = true;
+    console.log(`Serving queued request. Queue length: ${connectionPool.pendingRequests.length}`);
+    resolve({
+      connection: conn.connection,
+      release: () => releaseConnection(conn)
+    });
+  } else {
+    // Return to pool
+    connectionPool.connections.push(conn);
+    console.log(`Connection returned to pool. Pool size: ${connectionPool.connections.length}, Active: ${connectionPool.currentConnections}`);
+  }
+}
+
+/**
+ * Get cached query results or execute query if not cached
+ * @param {string} cacheKey - Unique key to identify the query
+ * @param {string} queryType - Type of query (stats, products, orders, etc.)
+ * @param {Function} queryFn - Function to execute if cache miss
+ * @returns {Promise<any>} The query result
+ */
+async function getCachedQuery(cacheKey, queryType, queryFn) {
+  // Get cache duration based on query type
+  const cacheDuration = connectionPool.cacheDuration[queryType] || connectionPool.cacheDuration.default;
+  
+  // Check if we have a valid cached result
+  const cachedResult = connectionPool.queryCache.get(cacheKey);
+  const now = Date.now();
+  
+  if (cachedResult && (now - cachedResult.timestamp < cacheDuration)) {
+    console.log(`Cache hit for ${queryType} query: ${cacheKey}`);
+    return cachedResult.data;
+  }
+  
+  // No valid cache found, execute the query
+  console.log(`Cache miss for ${queryType} query: ${cacheKey}`);
+  const result = await queryFn();
+  
+  // Cache the result
+  connectionPool.queryCache.set(cacheKey, {
+    data: result,
+    timestamp: now
+  });
+  
+  return result;
+}
+
+/**
+ * Setup SSH tunnel to production database
+ * @private - Should only be used by getDbConnection
+ * @returns {Promise<{ssh: object, stream: object, dbConfig: object}>}
+ */
+async function setupSshTunnel() {
+  const sshConfig = {
+    host: process.env.PROD_SSH_HOST,
+    port: process.env.PROD_SSH_PORT || 22,
+    username: process.env.PROD_SSH_USER,
+    privateKey: process.env.PROD_SSH_KEY_PATH
+      ? fs.readFileSync(process.env.PROD_SSH_KEY_PATH)
+      : undefined,
+    compress: true
+  };
+
+  const dbConfig = {
+    host: process.env.PROD_DB_HOST || 'localhost',
+    user: process.env.PROD_DB_USER,
+    password: process.env.PROD_DB_PASSWORD,
+    database: process.env.PROD_DB_NAME,
+    port: process.env.PROD_DB_PORT || 3306,
+    timezone: 'Z'
+  };
+
+  return new Promise((resolve, reject) => {
+    const ssh = new Client();
+
+    ssh.on('error', (err) => {
+      console.error('SSH connection error:', err);
+      reject(err);
+    });
+
+    ssh.on('ready', () => {
+      ssh.forwardOut(
+        '127.0.0.1',
+        0,
+        dbConfig.host,
+        dbConfig.port,
+        (err, stream) => {
+          if (err) reject(err);
+          resolve({ ssh, stream, dbConfig });
+        }
+      );
+    }).connect(sshConfig);
+  });
+}
+
+/**
+ * Clear cached query results
+ * @param {string} [cacheKey] - Specific cache key to clear (clears all if not provided)
+ */
+function clearQueryCache(cacheKey) {
+  if (cacheKey) {
+    connectionPool.queryCache.delete(cacheKey);
+    console.log(`Cleared cache for key: ${cacheKey}`);
+  } else {
+    connectionPool.queryCache.clear();
+    console.log('Cleared all query cache');
+  }
+}
+
+/**
+ * Force close all active connections
+ * Useful for server shutdown or manual connection reset
+ */
+async function closeAllConnections() {
+  // Close all pooled connections
+  for (const conn of connectionPool.connections) {
+    try {
+      await conn.connection.end();
+      conn.ssh.end();
+      console.log('Closed pooled connection');
+    } catch (error) {
+      console.error('Error closing pooled connection:', error);
+    }
+  }
+  
+  // Reset pool state
+  connectionPool.connections = [];
+  connectionPool.currentConnections = 0;
+  connectionPool.pendingRequests = [];
+  connectionPool.queryCache.clear();
+  
+  console.log('All connections closed and pool reset');
+}
+
+/**
+ * Get connection pool status for debugging
+ */
+function getPoolStatus() {
+  return {
+    poolSize: connectionPool.connections.length,
+    activeConnections: connectionPool.currentConnections,
+    maxConnections: connectionPool.maxConnections,
+    pendingRequests: connectionPool.pendingRequests.length,
+    cacheSize: connectionPool.queryCache.size,
+    queuedRequests: connectionPool.pendingRequests.map(req => ({
+      waitTime: Date.now() - req.timestamp,
+      hasTimeout: !!req.timeoutId
+    }))
+  };
+}
+
+module.exports = {
+  getDbConnection,
+  getCachedQuery,
+  clearQueryCache,
+  closeAllConnections,
+  getPoolStatus
+}; 

inventory-server/dashboard/acot-server/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "acot-server",
+  "version": "1.0.0",
+  "description": "A Cherry On Top production database server",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "express": "^4.18.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "morgan": "^1.10.0",
+    "ssh2": "^1.14.0",
+    "mysql2": "^3.6.5",
+    "compression": "^1.7.4"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.1"
+  }
+} 

inventory-server/dashboard/acot-server/routes/events.js

@@ -0,0 +1,767 @@
+const express = require('express');
+const router = express.Router();
+const { getDbConnection, getPoolStatus } = require('../db/connection');
+const { getTimeRangeConditions, formatBusinessDate, getBusinessDayBounds } = require('../utils/timeUtils');
+
+// Image URL generation utility
+const getImageUrls = (pid, iid = 1) => {
+  const imageUrlBase = 'https://sbing.com/i/products/0000/';
+  const paddedPid = pid.toString().padStart(6, '0');
+  const prefix = paddedPid.slice(0, 3);
+  const basePath = `${imageUrlBase}${prefix}/${pid}`;
+  return {
+    image: `${basePath}-t-${iid}.jpg`,
+    image_175: `${basePath}-175x175-${iid}.jpg`,
+    image_full: `${basePath}-o-${iid}.jpg`,
+    ImgThumb: `${basePath}-175x175-${iid}.jpg` // For ProductGrid component
+  };
+};
+
+// Main stats endpoint - replaces /api/klaviyo/events/stats
+router.get('/stats', async (req, res) => {
+  const startTime = Date.now();
+  console.log(`[STATS] Starting request for timeRange: ${req.query.timeRange}`);
+  
+  // Set a timeout for the entire operation
+  const timeoutPromise = new Promise((_, reject) => {
+    setTimeout(() => reject(new Error('Request timeout after 15 seconds')), 15000);
+  });
+  
+  try {
+    const mainOperation = async () => {
+      const { timeRange, startDate, endDate } = req.query;
+      console.log(`[STATS] Getting DB connection...`);
+      const { connection, release } = await getDbConnection();
+      console.log(`[STATS] DB connection obtained in ${Date.now() - startTime}ms`);
+    
+    const { whereClause, params, dateRange } = getTimeRangeConditions(timeRange, startDate, endDate);
+    
+    // Main order stats query
+    const mainStatsQuery = `
+      SELECT 
+        COUNT(*) as orderCount,
+        SUM(summary_total) as revenue,
+        SUM(stats_prod_pieces) as itemCount,
+        AVG(summary_total) as averageOrderValue,
+        AVG(stats_prod_pieces) as averageItemsPerOrder,
+        SUM(CASE WHEN stats_waiting_preorder > 0 THEN 1 ELSE 0 END) as preOrderCount,
+        SUM(CASE WHEN ship_method_selected = 'localpickup' THEN 1 ELSE 0 END) as localPickupCount,
+        SUM(CASE WHEN ship_method_selected = 'holdit' THEN 1 ELSE 0 END) as onHoldCount,
+        SUM(CASE WHEN order_status IN (100, 92) THEN 1 ELSE 0 END) as shippedCount,
+        SUM(CASE WHEN order_status = 15 THEN 1 ELSE 0 END) as cancelledCount,
+        SUM(CASE WHEN order_status = 15 THEN summary_total ELSE 0 END) as cancelledTotal
+      FROM _order 
+      WHERE order_status > 15 AND ${whereClause}
+    `;
+    
+    const [mainStats] = await connection.execute(mainStatsQuery, params);
+    const stats = mainStats[0];
+    
+    // Refunds query
+    const refundsQuery = `
+      SELECT 
+        COUNT(*) as refundCount,
+        ABS(SUM(payment_amount)) as refundTotal
+      FROM order_payment op
+      JOIN _order o ON op.order_id = o.order_id
+      WHERE payment_amount < 0 AND o.order_status > 15 AND ${whereClause.replace('date_placed', 'o.date_placed')}
+    `;
+    
+    const [refundStats] = await connection.execute(refundsQuery, params);
+    
+    // Best revenue day query
+    const bestDayQuery = `
+      SELECT 
+        DATE(date_placed) as date,
+        SUM(summary_total) as revenue,
+        COUNT(*) as orders
+      FROM _order 
+      WHERE order_status > 15 AND ${whereClause}
+      GROUP BY DATE(date_placed)
+      ORDER BY revenue DESC
+      LIMIT 1
+    `;
+    
+    const [bestDayResult] = await connection.execute(bestDayQuery, params);
+    
+    // Peak hour query (for single day periods)
+    let peakHour = null;
+    if (['today', 'yesterday'].includes(timeRange)) {
+      const peakHourQuery = `
+        SELECT 
+          HOUR(date_placed) as hour,
+          COUNT(*) as count
+        FROM _order 
+        WHERE order_status > 15 AND ${whereClause}
+        GROUP BY HOUR(date_placed)
+        ORDER BY count DESC
+        LIMIT 1
+      `;
+      
+      const [peakHourResult] = await connection.execute(peakHourQuery, params);
+      if (peakHourResult.length > 0) {
+        const hour = peakHourResult[0].hour;
+        const date = new Date();
+        date.setHours(hour, 0, 0);
+        peakHour = {
+          hour,
+          count: peakHourResult[0].count,
+          displayHour: date.toLocaleString("en-US", { hour: "numeric", hour12: true })
+        };
+      }
+    }
+    
+    // Brands and categories query - simplified for now since we don't have the category tables
+    // We'll use a simple approach without company table for now
+    const brandsQuery = `
+      SELECT 
+        'Various Brands' as brandName,
+        COUNT(DISTINCT oi.order_id) as orderCount,
+        SUM(oi.qty_ordered) as itemCount,
+        SUM(oi.qty_ordered * oi.prod_price) as revenue
+      FROM order_items oi
+      JOIN _order o ON oi.order_id = o.order_id
+      JOIN products p ON oi.prod_pid = p.pid
+      WHERE o.order_status > 15 AND ${whereClause.replace('date_placed', 'o.date_placed')}
+      HAVING revenue > 0
+    `;
+    
+    const [brandsResult] = await connection.execute(brandsQuery, params);
+    
+    // For categories, we'll use a simplified approach
+    const categoriesQuery = `
+      SELECT 
+        'General' as categoryName,
+        COUNT(DISTINCT oi.order_id) as orderCount,
+        SUM(oi.qty_ordered) as itemCount,
+        SUM(oi.qty_ordered * oi.prod_price) as revenue
+      FROM order_items oi
+      JOIN _order o ON oi.order_id = o.order_id
+      JOIN products p ON oi.prod_pid = p.pid
+      WHERE o.order_status > 15 AND ${whereClause.replace('date_placed', 'o.date_placed')}
+      HAVING revenue > 0
+    `;
+    
+    const [categoriesResult] = await connection.execute(categoriesQuery, params);
+    
+    // Shipping locations query
+    const shippingQuery = `
+      SELECT 
+        ship_country,
+        ship_state,
+        ship_method_selected,
+        COUNT(*) as count
+      FROM _order 
+      WHERE order_status IN (100, 92) AND ${whereClause}
+      GROUP BY ship_country, ship_state, ship_method_selected
+    `;
+    
+    const [shippingResult] = await connection.execute(shippingQuery, params);
+    
+    // Process shipping data
+    const shippingStats = processShippingData(shippingResult, stats.shippedCount);
+    
+    // Order value range query
+    const orderRangeQuery = `
+      SELECT 
+        MIN(summary_total) as smallest,
+        MAX(summary_total) as largest
+      FROM _order 
+      WHERE order_status > 15 AND ${whereClause}
+    `;
+    
+    const [orderRangeResult] = await connection.execute(orderRangeQuery, params);
+    
+    // Calculate period progress for incomplete periods
+    let periodProgress = 100;
+    if (['today', 'thisWeek', 'thisMonth'].includes(timeRange)) {
+      periodProgress = calculatePeriodProgress(timeRange);
+    }
+    
+    // Previous period comparison data
+    const prevPeriodData = await getPreviousPeriodData(connection, timeRange, startDate, endDate);
+    
+    const response = {
+      timeRange: dateRange,
+      stats: {
+        revenue: parseFloat(stats.revenue || 0),
+        orderCount: parseInt(stats.orderCount || 0),
+        itemCount: parseInt(stats.itemCount || 0),
+        averageOrderValue: parseFloat(stats.averageOrderValue || 0),
+        averageItemsPerOrder: parseFloat(stats.averageItemsPerOrder || 0),
+        
+        // Order types
+        orderTypes: {
+          preOrders: {
+            count: parseInt(stats.preOrderCount || 0),
+            percentage: stats.orderCount > 0 ? (stats.preOrderCount / stats.orderCount) * 100 : 0
+          },
+          localPickup: {
+            count: parseInt(stats.localPickupCount || 0),
+            percentage: stats.orderCount > 0 ? (stats.localPickupCount / stats.orderCount) * 100 : 0
+          },
+          heldItems: {
+            count: parseInt(stats.onHoldCount || 0),
+            percentage: stats.orderCount > 0 ? (stats.onHoldCount / stats.orderCount) * 100 : 0
+          }
+        },
+        
+        // Shipping
+        shipping: {
+          shippedCount: parseInt(stats.shippedCount || 0),
+          locations: shippingStats.locations,
+          methodStats: shippingStats.methods
+        },
+        
+        // Brands and categories
+        brands: {
+          total: brandsResult.length,
+          list: brandsResult.slice(0, 50).map(brand => ({
+            name: brand.brandName,
+            count: parseInt(brand.itemCount),
+            revenue: parseFloat(brand.revenue)
+          }))
+        },
+        
+        categories: {
+          total: categoriesResult.length,
+          list: categoriesResult.slice(0, 50).map(category => ({
+            name: category.categoryName,
+            count: parseInt(category.itemCount),
+            revenue: parseFloat(category.revenue)
+          }))
+        },
+        
+        // Refunds and cancellations
+        refunds: {
+          total: parseFloat(refundStats[0]?.refundTotal || 0),
+          count: parseInt(refundStats[0]?.refundCount || 0)
+        },
+        
+        canceledOrders: {
+          total: parseFloat(stats.cancelledTotal || 0),
+          count: parseInt(stats.cancelledCount || 0)
+        },
+        
+        // Best day
+        bestRevenueDay: bestDayResult.length > 0 ? {
+          amount: parseFloat(bestDayResult[0].revenue),
+          displayDate: bestDayResult[0].date,
+          orders: parseInt(bestDayResult[0].orders)
+        } : null,
+        
+        // Peak hour (for single days)
+        peakOrderHour: peakHour,
+        
+        // Order value range
+        orderValueRange: orderRangeResult.length > 0 ? {
+          smallest: parseFloat(orderRangeResult[0].smallest || 0),
+          largest: parseFloat(orderRangeResult[0].largest || 0)
+        } : { smallest: 0, largest: 0 },
+        
+        // Period progress and projections
+        periodProgress,
+        projectedRevenue: periodProgress < 100 ? (stats.revenue / (periodProgress / 100)) : stats.revenue,
+        
+        // Previous period comparison
+        prevPeriodRevenue: prevPeriodData.revenue,
+        prevPeriodOrders: prevPeriodData.orderCount,
+        prevPeriodAOV: prevPeriodData.averageOrderValue
+      }
+    };
+    
+    return { response, release };
+    };
+    
+    // Race between the main operation and timeout
+    let result;
+    try {
+      result = await Promise.race([mainOperation(), timeoutPromise]);
+    } catch (error) {
+      // If it's a timeout, we don't have a release function to call
+      if (error.message.includes('timeout')) {
+        console.log(`[STATS] Request timed out in ${Date.now() - startTime}ms`);
+        throw error;
+      }
+      // For other errors, re-throw
+      throw error;
+    }
+    
+    const { response, release } = result;
+    
+    // Release connection back to pool
+    if (release) release();
+    
+    console.log(`[STATS] Request completed in ${Date.now() - startTime}ms`);
+    res.json(response);
+    
+  } catch (error) {
+    console.error('Error in /stats:', error);
+    console.log(`[STATS] Request failed in ${Date.now() - startTime}ms`);
+    res.status(500).json({ error: error.message });
+  }
+});
+
+// Daily details endpoint - replaces /api/klaviyo/events/stats/details
+router.get('/stats/details', async (req, res) => {
+  let release;
+  try {
+    const { timeRange, startDate, endDate, metric, daily } = req.query;
+    const { connection, release: releaseConn } = await getDbConnection();
+    release = releaseConn;
+    
+    const { whereClause, params } = getTimeRangeConditions(timeRange, startDate, endDate);
+    
+    // Daily breakdown query
+    const dailyQuery = `
+      SELECT 
+        DATE(date_placed) as date,
+        COUNT(*) as orders,
+        SUM(summary_total) as revenue,
+        AVG(summary_total) as averageOrderValue,
+        SUM(stats_prod_pieces) as itemCount
+      FROM _order 
+      WHERE order_status > 15 AND ${whereClause}
+      GROUP BY DATE(date_placed)
+      ORDER BY DATE(date_placed)
+    `;
+    
+    const [dailyResults] = await connection.execute(dailyQuery, params);
+    
+    // Get previous period data using the same logic as main stats endpoint
+    let prevWhereClause, prevParams;
+    
+    if (timeRange && timeRange !== 'custom') {
+      const prevTimeRange = getPreviousTimeRange(timeRange);
+      const result = getTimeRangeConditions(prevTimeRange);
+      prevWhereClause = result.whereClause;
+      prevParams = result.params;
+    } else {
+      // Custom date range - go back by the same duration
+      const start = new Date(startDate);
+      const end = new Date(endDate);
+      const duration = end.getTime() - start.getTime();
+      
+      const prevEnd = new Date(start.getTime() - 1);
+      const prevStart = new Date(prevEnd.getTime() - duration);
+      
+      prevWhereClause = 'date_placed >= ? AND date_placed <= ?';
+      prevParams = [prevStart.toISOString(), prevEnd.toISOString()];
+    }
+
+    // Get previous period daily data
+    const prevQuery = `
+      SELECT 
+        DATE(date_placed) as date,
+        COUNT(*) as prevOrders,
+        SUM(summary_total) as prevRevenue,
+        AVG(summary_total) as prevAvgOrderValue
+      FROM _order 
+      WHERE order_status > 15 AND ${prevWhereClause}
+      GROUP BY DATE(date_placed)
+    `;
+    
+    const [prevResults] = await connection.execute(prevQuery, prevParams);
+    
+    // Create a map for quick lookup of previous period data
+    const prevMap = new Map();
+    prevResults.forEach(prev => {
+      const key = new Date(prev.date).toISOString().split('T')[0];
+      prevMap.set(key, prev);
+    });
+    
+    // For period-to-period comparison, we need to map days by relative position
+    // since dates won't match exactly (e.g., current week vs previous week)
+    const dailyArray = dailyResults.map(day => ({
+      timestamp: day.date,
+      date: day.date,
+      orders: parseInt(day.orders),
+      revenue: parseFloat(day.revenue),
+      averageOrderValue: parseFloat(day.averageOrderValue || 0),
+      itemCount: parseInt(day.itemCount)
+    }));
+
+    const prevArray = prevResults.map(day => ({
+      orders: parseInt(day.prevOrders),
+      revenue: parseFloat(day.prevRevenue),
+      averageOrderValue: parseFloat(day.prevAvgOrderValue || 0)
+    }));
+
+    // Combine current and previous period data by matching relative positions
+    const statsWithComparison = dailyArray.map((day, index) => {
+      const prev = prevArray[index] || { orders: 0, revenue: 0, averageOrderValue: 0 };
+      
+      return {
+        ...day,
+        prevOrders: prev.orders,
+        prevRevenue: prev.revenue,
+        prevAvgOrderValue: prev.averageOrderValue
+      };
+    });
+    
+    res.json({ stats: statsWithComparison });
+    
+  } catch (error) {
+    console.error('Error in /stats/details:', error);
+    res.status(500).json({ error: error.message });
+  } finally {
+    // Release connection back to pool
+    if (release) release();
+  }
+});
+
+// Products endpoint - replaces /api/klaviyo/events/products
+router.get('/products', async (req, res) => {
+  let release;
+  try {
+    const { timeRange, startDate, endDate } = req.query;
+    const { connection, release: releaseConn } = await getDbConnection();
+    release = releaseConn;
+    
+    const { whereClause, params } = getTimeRangeConditions(timeRange, startDate, endDate);
+    
+    const productsQuery = `
+      SELECT 
+        p.pid,
+        p.description as name,
+        SUM(oi.qty_ordered) as totalQuantity,
+        SUM(oi.qty_ordered * oi.prod_price) as totalRevenue,
+        COUNT(DISTINCT oi.order_id) as orderCount,
+        (SELECT pi.iid FROM product_images pi WHERE pi.pid = p.pid AND pi.order = 255 LIMIT 1) as primary_iid
+      FROM order_items oi
+      JOIN _order o ON oi.order_id = o.order_id
+      JOIN products p ON oi.prod_pid = p.pid
+      WHERE o.order_status > 15 AND ${whereClause.replace('date_placed', 'o.date_placed')}
+      GROUP BY p.pid, p.description
+      ORDER BY totalRevenue DESC
+      LIMIT 500
+    `;
+    
+    const [productsResult] = await connection.execute(productsQuery, params);
+    
+    // Add image URLs to each product
+    const productsWithImages = productsResult.map(product => {
+      const imageUrls = getImageUrls(product.pid, product.primary_iid || 1);
+      return {
+        id: product.pid,
+        name: product.name,
+        totalQuantity: parseInt(product.totalQuantity),
+        totalRevenue: parseFloat(product.totalRevenue),
+        orderCount: parseInt(product.orderCount),
+        ...imageUrls
+      };
+    });
+    
+    res.json({
+      stats: {
+        products: {
+          total: productsWithImages.length,
+          list: productsWithImages
+        }
+      }
+    });
+    
+  } catch (error) {
+    console.error('Error in /products:', error);
+    res.status(500).json({ error: error.message });
+  } finally {
+    // Release connection back to pool
+    if (release) release();
+  }
+});
+
+// Projection endpoint - replaces /api/klaviyo/events/projection
+router.get('/projection', async (req, res) => {
+  let release;
+  try {
+    const { timeRange, startDate, endDate } = req.query;
+    
+    // Only provide projections for incomplete periods
+    if (!['today', 'thisWeek', 'thisMonth'].includes(timeRange)) {
+      return res.json({ projectedRevenue: 0, confidence: 0 });
+    }
+    
+    const { connection, release: releaseConn } = await getDbConnection();
+    release = releaseConn;
+    
+    // Get current period data
+    const { whereClause, params } = getTimeRangeConditions(timeRange, startDate, endDate);
+    
+    const currentQuery = `
+      SELECT 
+        SUM(summary_total) as currentRevenue,
+        COUNT(*) as currentOrders
+      FROM _order 
+      WHERE order_status > 15 AND ${whereClause}
+    `;
+    
+    const [currentResult] = await connection.execute(currentQuery, params);
+    const current = currentResult[0];
+    
+    // Get historical data for the same period type
+    const historicalQuery = await getHistoricalProjectionData(connection, timeRange);
+    
+    // Calculate projection based on current progress and historical patterns
+    const periodProgress = calculatePeriodProgress(timeRange);
+    const projection = calculateSmartProjection(
+      parseFloat(current.currentRevenue || 0),
+      parseInt(current.currentOrders || 0),
+      periodProgress,
+      historicalQuery
+    );
+    
+    res.json(projection);
+    
+  } catch (error) {
+    console.error('Error in /projection:', error);
+    res.status(500).json({ error: error.message });
+  } finally {
+    // Release connection back to pool
+    if (release) release();
+  }
+});
+
+// Debug endpoint to check connection pool status
+router.get('/debug/pool', (req, res) => {
+  res.json(getPoolStatus());
+});
+
+// Health check endpoint
+router.get('/health', async (req, res) => {
+  try {
+    const { connection, release } = await getDbConnection();
+    
+    // Simple query to test connection
+    const [result] = await connection.execute('SELECT 1 as test');
+    release();
+    
+    res.json({ 
+      status: 'healthy', 
+      timestamp: new Date().toISOString(),
+      pool: getPoolStatus(),
+      dbTest: result[0]
+    });
+  } catch (error) {
+    res.status(500).json({ 
+      status: 'unhealthy', 
+      error: error.message,
+      timestamp: new Date().toISOString(),
+      pool: getPoolStatus()
+    });
+  }
+});
+
+// Helper functions
+function processShippingData(shippingResult, totalShipped) {
+  const countries = {};
+  const states = {};
+  const methods = {};
+  
+  shippingResult.forEach(row => {
+    // Countries
+    if (row.ship_country) {
+      countries[row.ship_country] = (countries[row.ship_country] || 0) + row.count;
+    }
+    
+    // States
+    if (row.ship_state) {
+      states[row.ship_state] = (states[row.ship_state] || 0) + row.count;
+    }
+    
+    // Methods
+    if (row.ship_method_selected) {
+      methods[row.ship_method_selected] = (methods[row.ship_method_selected] || 0) + row.count;
+    }
+  });
+  
+  return {
+    locations: {
+      total: totalShipped,
+      byCountry: Object.entries(countries)
+        .map(([country, count]) => ({
+          country,
+          count,
+          percentage: (count / totalShipped) * 100
+        }))
+        .sort((a, b) => b.count - a.count),
+      byState: Object.entries(states)
+        .map(([state, count]) => ({
+          state,
+          count,
+          percentage: (count / totalShipped) * 100
+        }))
+        .sort((a, b) => b.count - a.count)
+    },
+    methods: Object.entries(methods)
+      .map(([name, value]) => ({ name, value }))
+      .sort((a, b) => b.value - a.value)
+  };
+}
+
+function calculatePeriodProgress(timeRange) {
+  const now = new Date();
+  const easternTime = new Date(now.getTime() - (5 * 60 * 60 * 1000)); // UTC-5
+  
+  switch (timeRange) {
+    case 'today': {
+      const { start } = getBusinessDayBounds('today');
+      const businessStart = new Date(start);
+      const businessEnd = new Date(businessStart);
+      businessEnd.setDate(businessEnd.getDate() + 1);
+      businessEnd.setHours(0, 59, 59, 999); // 12:59 AM next day
+      
+      const elapsed = easternTime.getTime() - businessStart.getTime();
+      const total = businessEnd.getTime() - businessStart.getTime();
+      return Math.min(100, Math.max(0, (elapsed / total) * 100));
+    }
+    case 'thisWeek': {
+      const startOfWeek = new Date(easternTime);
+      startOfWeek.setDate(easternTime.getDate() - easternTime.getDay()); // Sunday
+      startOfWeek.setHours(1, 0, 0, 0); // 1 AM business day start
+      
+      const endOfWeek = new Date(startOfWeek);
+      endOfWeek.setDate(endOfWeek.getDate() + 7);
+      
+      const elapsed = easternTime.getTime() - startOfWeek.getTime();
+      const total = endOfWeek.getTime() - startOfWeek.getTime();
+      return Math.min(100, Math.max(0, (elapsed / total) * 100));
+    }
+    case 'thisMonth': {
+      const startOfMonth = new Date(easternTime.getFullYear(), easternTime.getMonth(), 1, 1, 0, 0, 0);
+      const endOfMonth = new Date(easternTime.getFullYear(), easternTime.getMonth() + 1, 1, 0, 59, 59, 999);
+      
+      const elapsed = easternTime.getTime() - startOfMonth.getTime();
+      const total = endOfMonth.getTime() - startOfMonth.getTime();
+      return Math.min(100, Math.max(0, (elapsed / total) * 100));
+    }
+    default:
+      return 100;
+  }
+}
+
+async function getPreviousPeriodData(connection, timeRange, startDate, endDate) {
+  // Calculate previous period dates
+  let prevWhereClause, prevParams;
+  
+  if (timeRange && timeRange !== 'custom') {
+    const prevTimeRange = getPreviousTimeRange(timeRange);
+    const result = getTimeRangeConditions(prevTimeRange);
+    prevWhereClause = result.whereClause;
+    prevParams = result.params;
+  } else {
+    // Custom date range - go back by the same duration
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    const duration = end.getTime() - start.getTime();
+    
+    const prevEnd = new Date(start.getTime() - 1);
+    const prevStart = new Date(prevEnd.getTime() - duration);
+    
+    prevWhereClause = 'date_placed >= ? AND date_placed <= ?';
+    prevParams = [prevStart.toISOString(), prevEnd.toISOString()];
+  }
+  
+  const prevQuery = `
+    SELECT 
+      COUNT(*) as orderCount,
+      SUM(summary_total) as revenue,
+      AVG(summary_total) as averageOrderValue
+    FROM _order 
+    WHERE order_status > 15 AND ${prevWhereClause}
+  `;
+  
+  const [prevResult] = await connection.execute(prevQuery, prevParams);
+  const prev = prevResult[0] || { orderCount: 0, revenue: 0, averageOrderValue: 0 };
+  
+  return {
+    orderCount: parseInt(prev.orderCount || 0),
+    revenue: parseFloat(prev.revenue || 0),
+    averageOrderValue: parseFloat(prev.averageOrderValue || 0)
+  };
+}
+
+function getPreviousTimeRange(timeRange) {
+  const map = {
+    today: 'yesterday',
+    thisWeek: 'lastWeek',
+    thisMonth: 'lastMonth',
+    last7days: 'previous7days',
+    last30days: 'previous30days',
+    last90days: 'previous90days',
+    yesterday: 'twoDaysAgo'
+  };
+  return map[timeRange] || timeRange;
+}
+
+async function getHistoricalProjectionData(connection, timeRange) {
+  // Get historical data for projection calculations
+  // This is a simplified version - you could make this more sophisticated
+  const historicalQuery = `
+    SELECT 
+      SUM(summary_total) as revenue,
+      COUNT(*) as orders
+    FROM _order 
+    WHERE order_status > 15 
+      AND date_placed >= DATE_SUB(NOW(), INTERVAL 30 DAY)
+      AND date_placed < DATE_SUB(NOW(), INTERVAL 1 DAY)
+  `;
+  
+  const [result] = await connection.execute(historicalQuery);
+  return result;
+}
+
+function calculateSmartProjection(currentRevenue, currentOrders, periodProgress, historicalData) {
+  if (periodProgress >= 100) {
+    return { projectedRevenue: currentRevenue, projectedOrders: currentOrders, confidence: 1.0 };
+  }
+  
+  // Simple linear projection with confidence based on how much of the period has elapsed
+  const projectedRevenue = currentRevenue / (periodProgress / 100);
+  const projectedOrders = Math.round(currentOrders / (periodProgress / 100));
+  
+  // Confidence increases with more data (higher period progress)
+  const confidence = Math.min(0.95, Math.max(0.1, periodProgress / 100));
+  
+  return {
+    projectedRevenue,
+    projectedOrders,
+    confidence
+  };
+}
+
+// Health check endpoint
+router.get('/health', async (req, res) => {
+  try {
+    const poolStatus = getPoolStatus();
+    
+    // Test database connectivity
+    const { connection, release } = await getDbConnection();
+    await connection.execute('SELECT 1 as test');
+    release();
+    
+    res.json({
+      status: 'healthy',
+      timestamp: new Date().toISOString(),
+      pool: poolStatus,
+      database: 'connected'
+    });
+  } catch (error) {
+    console.error('Health check failed:', error);
+    res.status(500).json({
+      status: 'unhealthy',
+      timestamp: new Date().toISOString(),
+      error: error.message,
+      pool: getPoolStatus()
+    });
+  }
+});
+
+// Debug endpoint for pool status
+router.get('/debug/pool', (req, res) => {
+  res.json({
+    timestamp: new Date().toISOString(),
+    pool: getPoolStatus()
+  });
+});
+
+module.exports = router; 

inventory-server/dashboard/acot-server/routes/test.js

@@ -0,0 +1,57 @@
+const express = require('express');
+const router = express.Router();
+const { getDbConnection, getCachedQuery } = require('../db/connection');
+
+// Test endpoint to count orders
+router.get('/order-count', async (req, res) => {
+  try {
+    const { connection } = await getDbConnection();
+    
+    // Simple query to count orders from _order table
+    const queryFn = async () => {
+      const [rows] = await connection.execute('SELECT COUNT(*) as count FROM _order');
+      return rows[0].count;
+    };
+    
+    const cacheKey = 'order-count';
+    const count = await getCachedQuery(cacheKey, 'default', queryFn);
+    
+    res.json({
+      success: true,
+      data: {
+        orderCount: count,
+        timestamp: new Date().toISOString()
+      }
+    });
+  } catch (error) {
+    console.error('Error fetching order count:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+// Test connection endpoint
+router.get('/test-connection', async (req, res) => {
+  try {
+    const { connection } = await getDbConnection();
+    
+    // Test the connection with a simple query
+    const [rows] = await connection.execute('SELECT 1 as test');
+    
+    res.json({
+      success: true,
+      message: 'Database connection successful',
+      data: rows[0]
+    });
+  } catch (error) {
+    console.error('Error testing connection:', error);
+    res.status(500).json({
+      success: false,
+      error: error.message
+    });
+  }
+});
+
+module.exports = router; 

inventory-server/dashboard/acot-server/server.js

@@ -0,0 +1,98 @@
+require('dotenv').config();
+const express = require('express');
+const cors = require('cors');
+const morgan = require('morgan');
+const compression = require('compression');
+const fs = require('fs');
+const path = require('path');
+const { closeAllConnections } = require('./db/connection');
+
+const app = express();
+const PORT = process.env.ACOT_PORT || 3012;
+
+// Create logs directory if it doesn't exist
+const logDir = path.join(__dirname, 'logs/app');
+if (!fs.existsSync(logDir)) {
+  fs.mkdirSync(logDir, { recursive: true });
+}
+
+// Create a write stream for access logs
+const accessLogStream = fs.createWriteStream(
+  path.join(logDir, 'access.log'),
+  { flags: 'a' }
+);
+
+// Middleware
+app.use(compression());
+app.use(cors());
+app.use(express.json());
+app.use(express.urlencoded({ extended: true }));
+
+// Logging middleware
+if (process.env.NODE_ENV === 'production') {
+  app.use(morgan('combined', { stream: accessLogStream }));
+} else {
+  app.use(morgan('dev'));
+}
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({
+    status: 'healthy',
+    service: 'acot-server',
+    timestamp: new Date().toISOString(),
+    uptime: process.uptime()
+  });
+});
+
+// Routes
+app.use('/api/acot/test', require('./routes/test'));
+app.use('/api/acot/events', require('./routes/events'));
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error('Unhandled error:', err);
+  res.status(500).json({
+    success: false,
+    error: process.env.NODE_ENV === 'production' 
+      ? 'Internal server error' 
+      : err.message
+  });
+});
+
+// 404 handler
+app.use((req, res) => {
+  res.status(404).json({
+    success: false,
+    error: 'Route not found'
+  });
+});
+
+// Start server
+const server = app.listen(PORT, () => {
+  console.log(`ACOT Server running on port ${PORT}`);
+  console.log(`Environment: ${process.env.NODE_ENV}`);
+});
+
+// Graceful shutdown
+const gracefulShutdown = async () => {
+  console.log('SIGTERM signal received: closing HTTP server');
+  server.close(async () => {
+    console.log('HTTP server closed');
+    
+    // Close database connections
+    try {
+      await closeAllConnections();
+      console.log('Database connections closed');
+    } catch (error) {
+      console.error('Error closing database connections:', error);
+    }
+    
+    process.exit(0);
+  });
+};
+
+process.on('SIGTERM', gracefulShutdown);
+process.on('SIGINT', gracefulShutdown);
+
+module.exports = app; 

inventory-server/dashboard/acot-server/utils/timeUtils.js

@@ -0,0 +1,259 @@
+// Time utilities for handling business day logic and time ranges
+// Business day is 1am-12:59am Eastern time (UTC-5)
+
+const getBusinessDayBounds = (timeRange) => {
+  const now = new Date();
+  const easternTime = new Date(now.getTime() - (5 * 60 * 60 * 1000)); // UTC-5
+  
+  switch (timeRange) {
+    case 'today': {
+      const start = new Date(easternTime);
+      start.setHours(1, 0, 0, 0); // 1 AM start of business day
+      
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      end.setHours(0, 59, 59, 999); // 12:59 AM next day
+      
+      return { start, end };
+    }
+    
+    case 'yesterday': {
+      const start = new Date(easternTime);
+      start.setDate(start.getDate() - 1);
+      start.setHours(1, 0, 0, 0);
+      
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      end.setHours(0, 59, 59, 999);
+      
+      return { start, end };
+    }
+    
+    case 'thisWeek': {
+      const start = new Date(easternTime);
+      start.setDate(easternTime.getDate() - easternTime.getDay()); // Sunday
+      start.setHours(1, 0, 0, 0);
+      
+      const end = new Date(easternTime);
+      end.setDate(end.getDate() + 1);
+      end.setHours(0, 59, 59, 999);
+      
+      return { start, end };
+    }
+    
+    case 'lastWeek': {
+      const start = new Date(easternTime);
+      start.setDate(easternTime.getDate() - easternTime.getDay() - 7); // Previous Sunday
+      start.setHours(1, 0, 0, 0);
+      
+      const end = new Date(start);
+      end.setDate(end.getDate() + 7);
+      end.setHours(0, 59, 59, 999);
+      
+      return { start, end };
+    }
+    
+    case 'thisMonth': {
+      const start = new Date(easternTime.getFullYear(), easternTime.getMonth(), 1, 1, 0, 0, 0);
+      const end = new Date(easternTime);
+      end.setDate(end.getDate() + 1);
+      end.setHours(0, 59, 59, 999);
+      
+      return { start, end };
+    }
+    
+    case 'lastMonth': {
+      const start = new Date(easternTime.getFullYear(), easternTime.getMonth() - 1, 1, 1, 0, 0, 0);
+      const end = new Date(easternTime.getFullYear(), easternTime.getMonth(), 1, 0, 59, 59, 999);
+      
+      return { start, end };
+    }
+    
+    case 'last7days': {
+      const end = new Date(easternTime);
+      end.setHours(0, 59, 59, 999);
+      
+      const start = new Date(end);
+      start.setDate(start.getDate() - 7);
+      start.setHours(1, 0, 0, 0);
+      
+      return { start, end };
+    }
+    
+    case 'last30days': {
+      const end = new Date(easternTime);
+      end.setHours(0, 59, 59, 999);
+      
+      const start = new Date(end);
+      start.setDate(start.getDate() - 30);
+      start.setHours(1, 0, 0, 0);
+      
+      return { start, end };
+    }
+    
+    case 'last90days': {
+      const end = new Date(easternTime);
+      end.setHours(0, 59, 59, 999);
+      
+      const start = new Date(end);
+      start.setDate(start.getDate() - 90);
+      start.setHours(1, 0, 0, 0);
+      
+      return { start, end };
+    }
+    
+    case 'previous7days': {
+      const end = new Date(easternTime);
+      end.setDate(end.getDate() - 1);
+      end.setHours(0, 59, 59, 999);
+      
+      const start = new Date(end);
+      start.setDate(start.getDate() - 6);
+      start.setHours(1, 0, 0, 0);
+      
+      return { start, end };
+    }
+    
+    case 'previous30days': {
+      const end = new Date(easternTime);
+      end.setDate(end.getDate() - 1);
+      end.setHours(0, 59, 59, 999);
+      
+      const start = new Date(end);
+      start.setDate(start.getDate() - 29);
+      start.setHours(1, 0, 0, 0);
+      
+      return { start, end };
+    }
+    
+    case 'previous90days': {
+      const end = new Date(easternTime);
+      end.setDate(end.getDate() - 1);
+      end.setHours(0, 59, 59, 999);
+      
+      const start = new Date(end);
+      start.setDate(start.getDate() - 89);
+      start.setHours(1, 0, 0, 0);
+      
+      return { start, end };
+    }
+    
+    case 'twoDaysAgo': {
+      const start = new Date(easternTime);
+      start.setDate(start.getDate() - 2);
+      start.setHours(1, 0, 0, 0);
+      
+      const end = new Date(start);
+      end.setDate(end.getDate() + 1);
+      end.setHours(0, 59, 59, 999);
+      
+      return { start, end };
+    }
+    
+    default:
+      throw new Error(`Unknown time range: ${timeRange}`);
+  }
+};
+
+const getTimeRangeConditions = (timeRange, startDate, endDate) => {
+  if (timeRange === 'custom' && startDate && endDate) {
+    // Custom date range
+    const start = new Date(startDate);
+    const end = new Date(endDate);
+    
+    // Convert to UTC-5 (Eastern time)
+    const startUTC5 = new Date(start.getTime() - (5 * 60 * 60 * 1000));
+    const endUTC5 = new Date(end.getTime() - (5 * 60 * 60 * 1000));
+    
+    return {
+      whereClause: 'date_placed >= ? AND date_placed <= ?',
+      params: [
+        startUTC5.toISOString().slice(0, 19).replace('T', ' '),
+        endUTC5.toISOString().slice(0, 19).replace('T', ' ')
+      ],
+      dateRange: {
+        start: startDate,
+        end: endDate,
+        label: `${formatBusinessDate(start)} - ${formatBusinessDate(end)}`
+      }
+    };
+  }
+  
+  if (!timeRange) {
+    timeRange = 'today';
+  }
+  
+  const { start, end } = getBusinessDayBounds(timeRange);
+  
+  // Convert to MySQL datetime format (UTC-5)
+  const startStr = start.toISOString().slice(0, 19).replace('T', ' ');
+  const endStr = end.toISOString().slice(0, 19).replace('T', ' ');
+  
+  return {
+    whereClause: 'date_placed >= ? AND date_placed <= ?',
+    params: [startStr, endStr],
+    dateRange: {
+      start: start.toISOString(),
+      end: end.toISOString(),
+      label: getTimeRangeLabel(timeRange)
+    }
+  };
+};
+
+const formatBusinessDate = (date) => {
+  return date.toLocaleDateString('en-US', {
+    month: 'short',
+    day: 'numeric',
+    year: 'numeric'
+  });
+};
+
+const getTimeRangeLabel = (timeRange) => {
+  const labels = {
+    today: 'Today',
+    yesterday: 'Yesterday',
+    thisWeek: 'This Week',
+    lastWeek: 'Last Week',
+    thisMonth: 'This Month',
+    lastMonth: 'Last Month',
+    last7days: 'Last 7 Days',
+    last30days: 'Last 30 Days',
+    last90days: 'Last 90 Days',
+    previous7days: 'Previous 7 Days',
+    previous30days: 'Previous 30 Days',
+    previous90days: 'Previous 90 Days',
+    twoDaysAgo: 'Two Days Ago'
+  };
+  
+  return labels[timeRange] || timeRange;
+};
+
+// Helper to convert MySQL datetime to JavaScript Date
+const parseBusinessDate = (mysqlDatetime) => {
+  if (!mysqlDatetime || mysqlDatetime === '0000-00-00 00:00:00') {
+    return null;
+  }
+  
+  // MySQL datetime is stored in UTC-5, so we need to add 5 hours to get UTC
+  const date = new Date(mysqlDatetime + ' UTC');
+  date.setHours(date.getHours() + 5);
+  return date;
+};
+
+// Helper to format date for MySQL queries
+const formatMySQLDate = (date) => {
+  if (!date) return null;
+  
+  // Convert to UTC-5 for storage
+  const utc5Date = new Date(date.getTime() - (5 * 60 * 60 * 1000));
+  return utc5Date.toISOString().slice(0, 19).replace('T', ' ');
+};
+
+module.exports = {
+  getBusinessDayBounds,
+  getTimeRangeConditions,
+  formatBusinessDate,
+  getTimeRangeLabel,
+  parseBusinessDate,
+  formatMySQLDate
+}; 

inventory-server/dashboard/aircall-server/.env.example

@@ -0,0 +1,21 @@
+# Server Configuration
+NODE_ENV=development
+AIRCALL_PORT=3002
+LOG_LEVEL=info
+
+# Aircall API Credentials
+AIRCALL_API_ID=your_aircall_api_id
+AIRCALL_API_TOKEN=your_aircall_api_token
+
+# Database Configuration
+MONGODB_URI=mongodb://localhost:27017/dashboard
+MONGODB_DB=dashboard
+REDIS_URL=redis://localhost:6379
+
+# Service Configuration
+TIMEZONE=America/New_York
+DAY_STARTS_AT=1 # Business day starts at 1 AM ET
+
+# Optional Settings
+REDIS_TTL=300 # Cache TTL in seconds (5 minutes)
+COLLECTION_NAME=aircall_daily_data

inventory-server/dashboard/aircall-server/README.md

@@ -0,0 +1,55 @@
+# Aircall Server
+
+A standalone server for handling Aircall metrics and data processing.
+
+## Setup
+
+1. Install dependencies:
+```bash
+npm install
+```
+
+2. Set up environment variables:
+```bash
+cp .env.example .env
+```
+Then edit `.env` with your configuration.
+
+Required environment variables:
+- `AIRCALL_API_ID`: Your Aircall API ID
+- `AIRCALL_API_TOKEN`: Your Aircall API Token
+- `MONGODB_URI`: MongoDB connection string
+- `REDIS_URL`: Redis connection string
+- `AIRCALL_PORT`: Server port (default: 3002)
+
+## Running the Server
+
+### Development
+```bash
+npm run dev
+```
+
+### Production
+Using PM2:
+```bash
+pm2 start ecosystem.config.js --env production
+```
+
+## API Endpoints
+
+### GET /api/aircall/metrics/:timeRange
+Get Aircall metrics for a specific time range.
+
+Parameters:
+- `timeRange`: One of ['today', 'yesterday', 'last7days', 'last30days', 'last90days']
+
+### GET /api/aircall/health
+Get server health status.
+
+## Architecture
+
+The server uses:
+- Express.js for the API
+- MongoDB for data storage
+- Redis for caching
+- Winston for logging 

inventory-server/dashboard/aircall-server/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "aircall-server",
+  "version": "1.0.0",
+  "description": "Aircall metrics server",
+  "type": "module",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "axios": "^1.6.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "mongodb": "^6.3.0",
+    "redis": "^4.6.11",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  }
+} 

inventory-server/dashboard/aircall-server/server.js

@@ -0,0 +1,83 @@
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { createRoutes } from './src/routes/index.js';
+import { aircallConfig } from './src/config/aircall.config.js';
+import { connectMongoDB } from './src/utils/db.js';
+import { createRedisClient } from './src/utils/redis.js';
+import { createLogger } from './src/utils/logger.js';
+
+// Get directory name in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load environment variables from the correct path
+dotenv.config({ path: path.resolve(__dirname, '.env') });
+
+// Validate required environment variables
+const requiredEnvVars = ['AIRCALL_API_ID', 'AIRCALL_API_TOKEN', 'MONGODB_URI', 'REDIS_URL'];
+const missingEnvVars = requiredEnvVars.filter(envVar => !process.env[envVar]);
+
+if (missingEnvVars.length > 0) {
+  console.error('Missing required environment variables:', missingEnvVars);
+  process.exit(1);
+}
+
+const app = express();
+const port = process.env.AIRCALL_PORT || 3002;
+const logger = createLogger('aircall-server');
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Connect to databases
+let mongodb;
+let redis;
+
+async function initializeServer() {
+  try {
+    // Connect to MongoDB
+    mongodb = await connectMongoDB();
+    logger.info('Connected to MongoDB');
+
+    // Connect to Redis
+    redis = await createRedisClient();
+    logger.info('Connected to Redis');
+
+    // Initialize configs with database connections
+    const configs = {
+      aircall: {
+        ...aircallConfig,
+        mongodb,
+        redis,
+        logger
+      }
+    };
+
+    // Initialize routes
+    const routes = createRoutes(configs, logger);
+    app.use('/api', routes);
+
+    // Error handling middleware
+    app.use((err, req, res, next) => {
+      logger.error('Server error:', err);
+      res.status(500).json({
+        error: 'Internal server error',
+        message: err.message
+      });
+    });
+
+    // Start server
+    app.listen(port, () => {
+      logger.info(`Aircall server listening on port ${port}`);
+    });
+  } catch (error) {
+    logger.error('Failed to initialize server:', error);
+    process.exit(1);
+  }
+}
+
+initializeServer(); 

inventory-server/dashboard/aircall-server/src/config/aircall.config.js

@@ -0,0 +1,15 @@
+export const aircallConfig = {
+  serviceName: 'aircall',
+  apiId: process.env.AIRCALL_API_ID,
+  apiToken: process.env.AIRCALL_API_TOKEN,
+  timezone: 'America/New_York',
+  dayStartsAt: 1,
+  storeHistory: true,
+  collection: 'aircall_daily_data',
+  redisTTL: 300, // 5 minutes cache for current day
+  endpoints: {
+    metrics: {
+      ttl: 300
+    }
+  }
+}; 

inventory-server/dashboard/aircall-server/src/routes/aircall.routes.js

@@ -0,0 +1,57 @@
+import express from 'express';
+import { AircallService } from '../services/aircall/AircallService.js';
+
+export const createAircallRoutes = (config, logger) => {
+  const router = express.Router();
+  const aircallService = new AircallService(config);
+
+  router.get('/metrics/:timeRange?', async (req, res) => {
+    try {
+      const { timeRange = 'today' } = req.params;
+      const allowedRanges = ['today', 'yesterday', 'last7days', 'last30days', 'last90days'];
+      
+      if (!allowedRanges.includes(timeRange)) {
+        return res.status(400).json({ 
+          error: 'Invalid time range',
+          allowedRanges 
+        });
+      }
+
+      const metrics = await aircallService.getMetrics(timeRange);
+      
+      res.json({
+        ...metrics,
+        _meta: {
+          timeRange,
+          generatedAt: new Date().toISOString(),
+          dataPoints: metrics.daily_data?.length || 0
+        }
+      });
+    } catch (error) {
+      logger.error('Error fetching Aircall metrics:', error);
+      res.status(500).json({ 
+        error: 'Failed to fetch Aircall metrics',
+        message: error.message 
+      });
+    }
+  });
+
+  // Health check endpoint
+  router.get('/health', (req, res) => {
+    const mongoConnected = !!aircallService.mongodb?.db;
+    const redisConnected = !!aircallService.redis?.isOpen;
+    
+    const health = {
+      status: mongoConnected && redisConnected ? 'ok' : 'degraded',
+      service: 'aircall',
+      timestamp: new Date().toISOString(),
+      connections: {
+        mongodb: mongoConnected,
+        redis: redisConnected
+      }
+    };
+    res.json(health);
+  });
+
+  return router;
+}; 

inventory-server/dashboard/aircall-server/src/routes/index.js

@@ -0,0 +1,32 @@
+import express from 'express';
+import { createAircallRoutes } from './aircall.routes.js';
+
+export const createRoutes = (configs, logger) => {
+  const router = express.Router();
+  
+  // Mount Aircall routes
+  router.use('/aircall', createAircallRoutes(configs.aircall, logger));
+
+  // Health check endpoint
+  router.get('/health', (req, res) => {
+    const services = req.services || {};
+    res.status(200).json({
+      status: 'ok',
+      timestamp: new Date(),
+      services: {
+        redis: services.redis?.isReady || false,
+        mongodb: services.mongo?.readyState === 1 || false
+      }
+    });
+  });
+
+  // Catch-all 404 handler
+  router.use('*', (req, res) => {
+    res.status(404).json({
+      error: 'Not Found',
+      message: `Route ${req.originalUrl} not found`
+    });
+  });
+
+  return router;
+}; 

inventory-server/dashboard/aircall-server/src/services/aircall/AircallDataManager.js

@@ -0,0 +1,298 @@
+import { DataManager } from "../base/DataManager.js";
+
+export class AircallDataManager extends DataManager {
+  constructor(mongodb, redis, timeManager) {
+    const options = {
+      collection: "aircall_daily_data",
+      redisTTL: 300 // 5 minutes cache
+    };
+    super(mongodb, redis, timeManager, options);
+    this.options = options;
+  }
+
+  ensureDate(d) {
+    if (d instanceof Date) return d;
+    if (typeof d === 'string') return new Date(d);
+    if (typeof d === 'number') return new Date(d);
+    console.error('Invalid date value:', d);
+    return new Date(); // fallback to current date
+  }
+
+  async storeHistoricalPeriod(start, end, calls) {
+    if (!this.mongodb) return;
+  
+    try {
+      if (!Array.isArray(calls)) {
+        console.error("Invalid calls data:", calls);
+        return;
+      }
+  
+      // Group calls by true day boundaries using TimeManager
+      const dailyCallsMap = new Map();
+  
+      calls.forEach((call) => {
+        try {
+          const timestamp = call.started_at * 1000; // Convert to milliseconds
+          const callDate = this.ensureDate(timestamp);
+          const dayBounds = this.timeManager.getDayBounds(callDate);
+          const dayKey = dayBounds.start.toISOString();
+          
+          if (!dailyCallsMap.has(dayKey)) {
+            dailyCallsMap.set(dayKey, {
+              date: dayBounds.start,
+              calls: [],
+            });
+          }
+          dailyCallsMap.get(dayKey).calls.push(call);
+        } catch (err) {
+          console.error('Error processing call:', err, call);
+        }
+      });
+  
+      // Iterate over each day in the period using day boundaries
+      const dates = [];
+      let currentDate = this.ensureDate(start);
+      const endDate = this.ensureDate(end);
+      
+      while (currentDate < endDate) {
+        const dayBounds = this.timeManager.getDayBounds(currentDate);
+        dates.push(dayBounds.start);
+        currentDate.setUTCDate(currentDate.getUTCDate() + 1);
+      }
+  
+      for (const date of dates) {
+        try {
+          const dateKey = date.toISOString();
+          const dayData = dailyCallsMap.get(dateKey);
+          const dayCalls = dayData ? dayData.calls : [];
+    
+          // Process calls for this day using the same processing logic
+          const metrics = this.processCallData(dayCalls);
+    
+          // Insert a daily_data record for this day
+          metrics.daily_data = [
+            {
+              date: date.toISOString().split("T")[0],
+              inbound: metrics.by_direction.inbound,
+              outbound: metrics.by_direction.outbound,
+            },
+          ];
+    
+          // Store this day's processed data as historical
+          await this.storeHistoricalDay(date, metrics);
+        } catch (err) {
+          console.error('Error processing date:', err, date);
+        }
+      }
+  
+    } catch (error) {
+      console.error("Error storing historical period:", error, error.stack);
+      throw error;
+    }
+  }
+
+  processCallData(calls) {
+    // If calls is already processed (has total, by_direction, etc.), return it
+    if (calls && calls.total !== undefined) {
+      console.log('Data already processed:', {
+        total: calls.total,
+        by_direction: calls.by_direction
+      });
+      // Return a clean copy of the processed data
+      return {
+        total: calls.total,
+        by_direction: calls.by_direction,
+        by_status: calls.by_status,
+        by_missed_reason: calls.by_missed_reason,
+        by_hour: calls.by_hour,
+        by_users: calls.by_users,
+        daily_data: calls.daily_data,
+        duration_distribution: calls.duration_distribution,
+        average_duration: calls.average_duration
+      };
+    }
+
+    console.log('Processing raw calls:', {
+      count: calls.length,
+      sample: calls.length > 0 ? {
+        id: calls[0].id,
+        direction: calls[0].direction,
+        status: calls[0].status
+      } : null
+    });
+
+    // Process raw calls
+    const metrics = {
+      total: calls.length,
+      by_direction: { inbound: 0, outbound: 0 },
+      by_status: { answered: 0, missed: 0 },
+      by_missed_reason: {},
+      by_hour: Array(24).fill(0),
+      by_users: {},
+      daily_data: [],
+      duration_distribution: [
+        { range: "0-1m", count: 0 },
+        { range: "1-5m", count: 0 },
+        { range: "5-15m", count: 0 },
+        { range: "15-30m", count: 0 },
+        { range: "30m+", count: 0 },
+      ],
+      average_duration: 0,
+      total_duration: 0,
+    };
+
+    // Group calls by date for daily data
+    const dailyCallsMap = new Map();
+
+    calls.forEach((call) => {
+      try {
+        // Direction metrics
+        metrics.by_direction[call.direction]++;
+
+        // Get call date and hour using TimeManager
+        const timestamp = call.started_at * 1000; // Convert to milliseconds
+        const callDate = this.ensureDate(timestamp);
+        const dayBounds = this.timeManager.getDayBounds(callDate);
+        const dayKey = dayBounds.start.toISOString().split("T")[0];
+        const hour = callDate.getHours();
+        metrics.by_hour[hour]++;
+
+        // Status and duration metrics
+        if (call.answered_at) {
+          metrics.by_status.answered++;
+          const duration = call.ended_at - call.answered_at;
+          metrics.total_duration += duration;
+
+          // Duration distribution
+          if (duration <= 60) {
+            metrics.duration_distribution[0].count++;
+          } else if (duration <= 300) {
+            metrics.duration_distribution[1].count++;
+          } else if (duration <= 900) {
+            metrics.duration_distribution[2].count++;
+          } else if (duration <= 1800) {
+            metrics.duration_distribution[3].count++;
+          } else {
+            metrics.duration_distribution[4].count++;
+          }
+
+          // Track user performance
+          if (call.user) {
+            const userId = call.user.id;
+            if (!metrics.by_users[userId]) {
+              metrics.by_users[userId] = {
+                id: userId,
+                name: call.user.name,
+                total: 0,
+                answered: 0,
+                missed: 0,
+                total_duration: 0,
+                average_duration: 0,
+              };
+            }
+            metrics.by_users[userId].total++;
+            metrics.by_users[userId].answered++;
+            metrics.by_users[userId].total_duration += duration;
+          }
+        } else {
+          metrics.by_status.missed++;
+          if (call.missed_call_reason) {
+            metrics.by_missed_reason[call.missed_call_reason] =
+              (metrics.by_missed_reason[call.missed_call_reason] || 0) + 1;
+          }
+
+          // Track missed calls by user
+          if (call.user) {
+            const userId = call.user.id;
+            if (!metrics.by_users[userId]) {
+              metrics.by_users[userId] = {
+                id: userId,
+                name: call.user.name,
+                total: 0,
+                answered: 0,
+                missed: 0,
+                total_duration: 0,
+                average_duration: 0,
+              };
+            }
+            metrics.by_users[userId].total++;
+            metrics.by_users[userId].missed++;
+          }
+        }
+
+        // Group by date for daily data
+        if (!dailyCallsMap.has(dayKey)) {
+          dailyCallsMap.set(dayKey, { date: dayKey, inbound: 0, outbound: 0 });
+        }
+        dailyCallsMap.get(dayKey)[call.direction]++;
+      } catch (err) {
+        console.error('Error processing call:', err, call);
+      }
+    });
+
+    // Calculate average durations for users
+    Object.values(metrics.by_users).forEach((user) => {
+      if (user.answered > 0) {
+        user.average_duration = Math.round(user.total_duration / user.answered);
+      }
+    });
+
+    // Calculate global average duration
+    if (metrics.by_status.answered > 0) {
+      metrics.average_duration = Math.round(
+        metrics.total_duration / metrics.by_status.answered
+      );
+    }
+
+    // Convert daily data map to sorted array
+    metrics.daily_data = Array.from(dailyCallsMap.values()).sort((a, b) =>
+      a.date.localeCompare(b.date)
+    );
+
+    delete metrics.total_duration;
+
+    console.log('Processed metrics:', {
+      total: metrics.total,
+      by_direction: metrics.by_direction,
+      by_status: metrics.by_status,
+      daily_data_count: metrics.daily_data.length
+    });
+
+    return metrics;
+  }
+
+  async storeHistoricalDay(date, data) {
+    if (!this.mongodb) return;
+
+    try {
+      const collection = this.mongodb.collection(this.options.collection);
+      const dayBounds = this.timeManager.getDayBounds(this.ensureDate(date));
+
+      // Ensure consistent data structure with metrics nested in data field
+      const document = {
+        date: dayBounds.start,
+        data: {
+          total: data.total,
+          by_direction: data.by_direction,
+          by_status: data.by_status,
+          by_missed_reason: data.by_missed_reason,
+          by_hour: data.by_hour,
+          by_users: data.by_users,
+          daily_data: data.daily_data,
+          duration_distribution: data.duration_distribution,
+          average_duration: data.average_duration
+        },
+        updatedAt: new Date()
+      };
+
+      await collection.updateOne(
+        { date: dayBounds.start },
+        { $set: document },
+        { upsert: true }
+      );
+    } catch (error) {
+      console.error("Error storing historical day:", error);
+      throw error;
+    }
+  }
+}

inventory-server/dashboard/aircall-server/src/services/aircall/AircallService.js

@@ -0,0 +1,138 @@
+import axios from "axios";
+import { Buffer } from "buffer";
+import { BaseService } from "../base/BaseService.js";
+import { AircallDataManager } from "./AircallDataManager.js";
+
+export class AircallService extends BaseService {
+  constructor(config) {
+    super(config);
+    this.baseUrl = "https://api.aircall.io/v1";
+    console.log('Initializing Aircall service with credentials:', {
+      apiId: config.apiId ? 'present' : 'missing',
+      apiToken: config.apiToken ? 'present' : 'missing'
+    });
+    this.auth = Buffer.from(`${config.apiId}:${config.apiToken}`).toString(
+      "base64"
+    );
+    this.dataManager = new AircallDataManager(
+      this.mongodb,
+      this.redis,
+      this.timeManager
+    );
+
+    if (!config.apiId || !config.apiToken) {
+      throw new Error("Aircall API credentials are required");
+    }
+  }
+
+  async getMetrics(timeRange) {
+    const dateRange = await this.timeManager.getDateRange(timeRange);
+    console.log('Fetching metrics for date range:', {
+      start: dateRange.start.toISOString(),
+      end: dateRange.end.toISOString()
+    });
+
+    return this.dataManager.getData(dateRange, async (range) => {
+      const calls = await this.fetchAllCalls(range.start, range.end);
+      console.log('Fetched calls:', {
+        count: calls.length,
+        sample: calls.length > 0 ? calls[0] : null
+      });
+      return calls;
+    });
+  }
+
+  async fetchAllCalls(start, end) {
+    try {
+      let allCalls = [];
+      let currentPage = 1;
+      let hasMore = true;
+      let totalPages = null;
+
+      while (hasMore) {
+        const response = await this.makeRequest("/calls", {
+          from: Math.floor(start.getTime() / 1000),
+          to: Math.floor(end.getTime() / 1000),
+          order: "asc",
+          page: currentPage,
+          per_page: 50,
+        });
+
+        console.log('API Response:', {
+          page: currentPage,
+          totalPages: response.meta.total_pages,
+          callsCount: response.calls?.length,
+          params: {
+            from: Math.floor(start.getTime() / 1000),
+            to: Math.floor(end.getTime() / 1000)
+          }
+        });
+
+        if (!response.calls) {
+          throw new Error("Invalid API response format");
+        }
+
+        allCalls = [...allCalls, ...response.calls];
+        hasMore = response.meta.next_page_link !== null;
+        totalPages = response.meta.total_pages;
+        currentPage++;
+
+        if (hasMore) {
+          // Rate limiting pause
+          await new Promise((resolve) => setTimeout(resolve, 1));
+        }
+      }
+
+      return allCalls;
+    } catch (error) {
+      console.error("Error fetching all calls:", error);
+      throw error;
+    }
+  }
+
+  async makeRequest(endpoint, params = {}) {
+    try {
+      console.log('Making API request:', {
+        endpoint,
+        params
+      });
+      const response = await axios.get(`${this.baseUrl}${endpoint}`, {
+        headers: {
+          Authorization: `Basic ${this.auth}`,
+          "Content-Type": "application/json",
+        },
+        params,
+      });
+      return response.data;
+    } catch (error) {
+      if (error.response?.status === 429) {
+        console.log("Rate limit reached, waiting before retry...");
+        await new Promise((resolve) => setTimeout(resolve, 5000));
+        return this.makeRequest(endpoint, params);
+      }
+
+      this.handleApiError(error, `Error making request to ${endpoint}`);
+    }
+  }
+
+  validateApiResponse(response, context = "") {
+    if (!response || typeof response !== "object") {
+      throw new Error(`${context}: Invalid API response format`);
+    }
+
+    if (response.error) {
+      throw new Error(`${context}: ${response.error}`);
+    }
+
+    return true;
+  }
+
+  getPaginationInfo(meta) {
+    return {
+      currentPage: meta.current_page,
+      totalPages: meta.total_pages,
+      hasNextPage: meta.next_page_link !== null,
+      totalRecords: meta.total,
+    };
+  }
+} 

inventory-server/dashboard/aircall-server/src/services/base/BaseService.js

@@ -0,0 +1,32 @@
+import { createTimeManager } from '../../utils/timeUtils.js';
+
+export class BaseService {
+  constructor(config) {
+    this.config = config;
+    this.mongodb = config.mongodb;
+    this.redis = config.redis;
+    this.logger = config.logger;
+    this.timeManager = createTimeManager(config.timezone, config.dayStartsAt);
+  }
+
+  handleApiError(error, context = '') {
+    this.logger.error(`API Error ${context}:`, {
+      message: error.message,
+      status: error.response?.status,
+      data: error.response?.data,
+    });
+
+    if (error.response) {
+      const status = error.response.status;
+      const message = error.response.data?.message || error.response.statusText;
+
+      if (status === 429) {
+        throw new Error('API rate limit exceeded. Please try again later.');
+      }
+
+      throw new Error(`API error (${status}): ${message}`);
+    }
+
+    throw error;
+  }
+} 

inventory-server/dashboard/aircall-server/src/services/base/DataManager.js

@@ -0,0 +1,320 @@
+export class DataManager {
+  constructor(mongodb, redis, timeManager, options) {
+    this.mongodb = mongodb;
+    this.redis = redis;
+    this.timeManager = timeManager;
+    this.options = options || {};
+  }
+
+  ensureDate(d) {
+    if (d instanceof Date) return d;
+    if (typeof d === 'string') return new Date(d);
+    if (typeof d === 'number') return new Date(d);
+    if (d && d.date) return new Date(d.date); // Handle MongoDB records
+    console.error('Invalid date value:', d);
+    return new Date(); // fallback to current date
+  }
+
+  async getData(dateRange, fetchFn) {
+    try {
+      // Get historical data from MongoDB
+      const historicalData = await this.getHistoricalDays(dateRange.start, dateRange.end);
+      
+      // Find any missing date ranges
+      const missingRanges = this.findMissingDateRanges(dateRange.start, dateRange.end, historicalData);
+
+      // Fetch missing data
+      for (const range of missingRanges) {
+        const data = await fetchFn(range);
+        await this.storeHistoricalPeriod(range.start, range.end, data);
+      }
+
+      // Get updated historical data
+      const updatedData = await this.getHistoricalDays(dateRange.start, dateRange.end);
+      
+      // Handle both nested and flat data structures
+      if (updatedData && updatedData.length > 0) {
+        // Process each record and combine them
+        const processedData = updatedData.map(record => {
+          if (record.data) {
+            return record.data;
+          }
+          if (record.total !== undefined) {
+            return {
+              total: record.total,
+              by_direction: record.by_direction,
+              by_status: record.by_status,
+              by_missed_reason: record.by_missed_reason,
+              by_hour: record.by_hour,
+              by_users: record.by_users,
+              daily_data: record.daily_data,
+              duration_distribution: record.duration_distribution,
+              average_duration: record.average_duration
+            };
+          }
+          return null;
+        }).filter(Boolean);
+
+        // Combine the data
+        if (processedData.length > 0) {
+          return this.combineMetrics(processedData);
+        }
+      }
+      
+      // Otherwise process as raw call data
+      return this.processCallData(updatedData);
+    } catch (error) {
+      console.error('Error in getData:', error);
+      throw error;
+    }
+  }
+
+  findMissingDateRanges(start, end, existingDates) {
+    const missingRanges = [];
+    const existingDatesSet = new Set(
+      existingDates.map((d) => {
+        // Handle both nested and flat data structures
+        const date = d.date ? d.date : d;
+        return this.ensureDate(date).toISOString().split("T")[0];
+      })
+    );
+
+    let current = new Date(start);
+    const endDate = new Date(end);
+    
+    while (current < endDate) {
+      const dayBounds = this.timeManager.getDayBounds(current);
+      const dayKey = dayBounds.start.toISOString().split("T")[0];
+
+      if (!existingDatesSet.has(dayKey)) {
+        // Found a missing day
+        const missingStart = new Date(dayBounds.start);
+        const missingEnd = new Date(dayBounds.end);
+
+        missingRanges.push({
+          start: missingStart,
+          end: missingEnd,
+        });
+      }
+
+      // Move to the next day using timeManager to ensure proper business day boundaries
+      current = new Date(dayBounds.end.getTime() + 1);
+    }
+
+    return missingRanges;
+  }
+
+  async getCurrentDay(fetchFn) {
+    const now = new Date();
+    const todayBounds = this.timeManager.getDayBounds(now);
+    const todayKey = this.timeManager.formatDate(todayBounds.start);
+    const cacheKey = `${this.options.collection}:current_day:${todayKey}`;
+
+    try {
+      // Check cache first
+      if (this.redis?.isOpen) {
+        const cached = await this.redis.get(cacheKey);
+        if (cached) {
+          const parsedCache = JSON.parse(cached);
+          if (parsedCache.total !== undefined) {
+            // Use timeManager to check if the cached data is for today
+            const cachedDate = new Date(parsedCache.daily_data[0].date);
+            const isToday = this.timeManager.isToday(cachedDate);
+            
+            if (isToday) {
+              return parsedCache;
+            }
+          }
+        }
+      }
+
+      // Get safe end time that's never in the future
+      const safeEnd = this.timeManager.getCurrentBusinessDayEnd();
+
+      // Fetch and process current day data with safe end time
+      const data = await fetchFn({
+        start: todayBounds.start,
+        end: safeEnd
+      });
+
+      if (!data) {
+        return null;
+      }
+
+      // Cache the data with a shorter TTL for today's data
+      if (this.redis?.isOpen) {
+        const ttl = Math.min(
+          this.options.redisTTL,
+          60 * 5 // 5 minutes max for today's data
+        );
+        await this.redis.set(cacheKey, JSON.stringify(data), {
+          EX: ttl,
+        });
+      }
+
+      return data;
+    } catch (error) {
+      console.error('Error in getCurrentDay:', error);
+      throw error;
+    }
+  }
+
+  getDayCount(start, end) {
+    // Calculate full days between dates using timeManager
+    const startDay = this.timeManager.getDayBounds(start);
+    const endDay = this.timeManager.getDayBounds(end);
+    return Math.ceil((endDay.end - startDay.start) / (24 * 60 * 60 * 1000));
+  }
+
+  async fetchMissingDays(start, end, existingData, fetchFn) {
+    const existingDates = new Set(
+      existingData.map((d) => this.timeManager.formatDate(d.date))
+    );
+    const missingData = [];
+
+    let currentDate = new Date(start);
+    while (currentDate < end) {
+      const dayBounds = this.timeManager.getDayBounds(currentDate);
+      const dateString = this.timeManager.formatDate(dayBounds.start);
+      
+      if (!existingDates.has(dateString)) {
+        const data = await fetchFn({
+          start: dayBounds.start,
+          end: dayBounds.end,
+        });
+
+        await this.storeHistoricalDay(dayBounds.start, data);
+        missingData.push(data);
+      }
+
+      // Move to next day using timeManager to ensure proper business day boundaries
+      currentDate = new Date(dayBounds.end.getTime() + 1);
+    }
+
+    return missingData;
+  }
+
+  async getHistoricalDays(start, end) {
+    try {
+      if (!this.mongodb) return [];
+
+      const collection = this.mongodb.collection(this.options.collection);
+      const startDay = this.timeManager.getDayBounds(start);
+      const endDay = this.timeManager.getDayBounds(end);
+
+      const records = await collection
+        .find({
+          date: {
+            $gte: startDay.start,
+            $lt: endDay.start,
+          },
+        })
+        .sort({ date: 1 })
+        .toArray();
+
+      return records;
+    } catch (error) {
+      console.error('Error getting historical days:', error);
+      return [];
+    }
+  }
+
+  combineMetrics(metricsArray) {
+    if (!metricsArray || metricsArray.length === 0) return null;
+    if (metricsArray.length === 1) return metricsArray[0];
+
+    const combined = {
+      total: 0,
+      by_direction: { inbound: 0, outbound: 0 },
+      by_status: { answered: 0, missed: 0 },
+      by_missed_reason: {},
+      by_hour: Array(24).fill(0),
+      by_users: {},
+      daily_data: [],
+      duration_distribution: [
+        { range: '0-1m', count: 0 },
+        { range: '1-5m', count: 0 },
+        { range: '5-15m', count: 0 },
+        { range: '15-30m', count: 0 },
+        { range: '30m+', count: 0 }
+      ],
+      average_duration: 0
+    };
+
+    let totalAnswered = 0;
+    let totalDuration = 0;
+
+    metricsArray.forEach(metrics => {
+      // Sum basic metrics
+      combined.total += metrics.total;
+      combined.by_direction.inbound += metrics.by_direction.inbound;
+      combined.by_direction.outbound += metrics.by_direction.outbound;
+      combined.by_status.answered += metrics.by_status.answered;
+      combined.by_status.missed += metrics.by_status.missed;
+
+      // Combine missed reasons
+      Object.entries(metrics.by_missed_reason).forEach(([reason, count]) => {
+        combined.by_missed_reason[reason] = (combined.by_missed_reason[reason] || 0) + count;
+      });
+
+      // Sum hourly data
+      metrics.by_hour.forEach((count, hour) => {
+        combined.by_hour[hour] += count;
+      });
+
+      // Combine user data
+      Object.entries(metrics.by_users).forEach(([userId, userData]) => {
+        if (!combined.by_users[userId]) {
+          combined.by_users[userId] = {
+            id: userData.id,
+            name: userData.name,
+            total: 0,
+            answered: 0,
+            missed: 0,
+            total_duration: 0,
+            average_duration: 0
+          };
+        }
+        combined.by_users[userId].total += userData.total;
+        combined.by_users[userId].answered += userData.answered;
+        combined.by_users[userId].missed += userData.missed;
+        combined.by_users[userId].total_duration += userData.total_duration || 0;
+      });
+
+      // Combine duration distribution
+      metrics.duration_distribution.forEach((dist, index) => {
+        combined.duration_distribution[index].count += dist.count;
+      });
+
+      // Accumulate for average duration calculation
+      if (metrics.average_duration && metrics.by_status.answered) {
+        totalDuration += metrics.average_duration * metrics.by_status.answered;
+        totalAnswered += metrics.by_status.answered;
+      }
+
+      // Merge daily data
+      if (metrics.daily_data) {
+        combined.daily_data.push(...metrics.daily_data);
+      }
+    });
+
+    // Calculate final average duration
+    if (totalAnswered > 0) {
+      combined.average_duration = Math.round(totalDuration / totalAnswered);
+    }
+
+    // Calculate user averages
+    Object.values(combined.by_users).forEach(user => {
+      if (user.answered > 0) {
+        user.average_duration = Math.round(user.total_duration / user.answered);
+      }
+    });
+
+    // Sort and deduplicate daily data
+    combined.daily_data = Array.from(
+      new Map(combined.daily_data.map(item => [item.date, item])).values()
+    ).sort((a, b) => a.date.localeCompare(b.date));
+
+    return combined;
+  }
+} 

inventory-server/dashboard/aircall-server/src/utils/db.js

@@ -0,0 +1,15 @@
+import { MongoClient } from 'mongodb';
+
+const MONGODB_URI = process.env.MONGODB_URI || 'mongodb://localhost:27017/dashboard';
+const DB_NAME = process.env.MONGODB_DB || 'dashboard';
+
+export async function connectMongoDB() {
+  try {
+    const client = await MongoClient.connect(MONGODB_URI);
+    console.log('Connected to MongoDB');
+    return client.db(DB_NAME);
+  } catch (error) {
+    console.error('MongoDB connection error:', error);
+    throw error;
+  }
+} 

inventory-server/dashboard/aircall-server/src/utils/logger.js

@@ -0,0 +1,30 @@
+import winston from 'winston';
+import path from 'path';
+
+export function createLogger(service) {
+  return winston.createLogger({
+    level: process.env.LOG_LEVEL || 'info',
+    format: winston.format.combine(
+      winston.format.timestamp(),
+      winston.format.json()
+    ),
+    defaultMeta: { service },
+    transports: [
+      // Write all logs to console
+      new winston.transports.Console({
+        format: winston.format.combine(
+          winston.format.colorize(),
+          winston.format.simple()
+        )
+      }),
+      // Write all logs to service-specific files
+      new winston.transports.File({
+        filename: path.join('logs', `${service}-error.log`),
+        level: 'error'
+      }),
+      new winston.transports.File({
+        filename: path.join('logs', `${service}-combined.log`)
+      })
+    ]
+  });
+} 

inventory-server/dashboard/aircall-server/src/utils/redis.js

@@ -0,0 +1,23 @@
+import { createClient } from 'redis';
+
+const REDIS_URL = process.env.REDIS_URL || 'redis://localhost:6379';
+
+export async function createRedisClient() {
+  try {
+    const client = createClient({
+      url: REDIS_URL
+    });
+
+    await client.connect();
+    console.log('Connected to Redis');
+    
+    client.on('error', (err) => {
+      console.error('Redis error:', err);
+    });
+
+    return client;
+  } catch (error) {
+    console.error('Redis connection error:', error);
+    throw error;
+  }
+} 

inventory-server/dashboard/aircall-server/src/utils/timeUtils.js

@@ -0,0 +1,262 @@
+class TimeManager {
+  static ALLOWED_RANGES = ['today', 'yesterday', 'last2days', 'last7days', 'last30days', 'last90days', 
+                          'previous7days', 'previous30days', 'previous90days'];
+
+  constructor(timezone = 'America/New_York', dayStartsAt = 1) {
+    this.timezone = timezone;
+    this.dayStartsAt = dayStartsAt;
+  }
+
+  getDayBounds(date) {
+    try {
+      const now = new Date();
+      const targetDate = new Date(date);
+      
+      // For today
+      if (
+        targetDate.getUTCFullYear() === now.getUTCFullYear() &&
+        targetDate.getUTCMonth() === now.getUTCMonth() &&
+        targetDate.getUTCDate() === now.getUTCDate()
+      ) {
+        // If current time is before day start (1 AM ET / 6 AM UTC), 
+        // use previous day's start until now
+        const todayStart = new Date(Date.UTC(
+          now.getUTCFullYear(),
+          now.getUTCMonth(),
+          now.getUTCDate(),
+          this.dayStartsAt + 5,
+          0,
+          0,
+          0
+        ));
+  
+        if (now < todayStart) {
+          const yesterdayStart = new Date(todayStart);
+          yesterdayStart.setUTCDate(yesterdayStart.getUTCDate() - 1);
+          return { start: yesterdayStart, end: now };
+        }
+  
+        return { start: todayStart, end: now };
+      }
+  
+      // For past days, use full 24-hour period
+      const normalizedDate = new Date(Date.UTC(
+        targetDate.getUTCFullYear(),
+        targetDate.getUTCMonth(),
+        targetDate.getUTCDate()
+      ));
+
+      const dayStart = new Date(normalizedDate);
+      dayStart.setUTCHours(this.dayStartsAt + 5, 0, 0, 0);
+
+      const dayEnd = new Date(dayStart);
+      dayEnd.setUTCDate(dayEnd.getUTCDate() + 1);
+
+      return { start: dayStart, end: dayEnd };
+    } catch (error) {
+      console.error('Error in getDayBounds:', error);
+      throw new Error(`Failed to calculate day bounds: ${error.message}`);
+    }
+  }
+
+  getDateRange(period) {
+    try {
+      const now = new Date();
+      const todayBounds = this.getDayBounds(now);
+      const end = new Date();
+
+      switch (period) {
+        case 'today':
+          return {
+            start: todayBounds.start,
+            end
+          };
+        case 'yesterday': {
+          const yesterday = new Date(now);
+          yesterday.setDate(yesterday.getDate() - 1);
+          return this.getDayBounds(yesterday);
+        }
+        case 'last2days': {
+          const twoDaysAgo = new Date(now);
+          twoDaysAgo.setDate(twoDaysAgo.getDate() - 2);
+          return this.getDayBounds(twoDaysAgo);
+        }
+        case 'last7days': {
+          const start = new Date(now);
+          start.setDate(start.getDate() - 6);
+          return {
+            start: this.getDayBounds(start).start,
+            end
+          };
+        }
+        case 'previous7days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 7);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 6);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        case 'last30days': {
+          const start = new Date(now);
+          start.setDate(start.getDate() - 29);
+          return {
+            start: this.getDayBounds(start).start,
+            end
+          };
+        }
+        case 'previous30days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 30);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 29);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        case 'last90days': {
+          const start = new Date(now);
+          start.setDate(start.getDate() - 89);
+          return {
+            start: this.getDayBounds(start).start,
+            end
+          };
+        }
+        case 'previous90days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 90);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 89);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        default:
+          throw new Error(`Unsupported time period: ${period}`);
+      }
+    } catch (error) {
+      console.error('Error in getDateRange:', error);
+      throw error;
+    }
+  }
+
+  getPreviousPeriod(period) {
+    try {
+      const now = new Date();
+      
+      switch (period) {
+        case 'today': 
+          return 'yesterday';
+        case 'yesterday': {
+          // Return bounds for 2 days ago
+          const twoDaysAgo = new Date(now);
+          twoDaysAgo.setDate(twoDaysAgo.getDate() - 2);
+          return this.getDayBounds(twoDaysAgo);
+        }
+        case 'last7days': {
+          // Return bounds for previous 7 days
+          const end = new Date(now);
+          end.setDate(end.getDate() - 7);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 7);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        case 'last30days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 30);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 30);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        case 'last90days': {
+          const end = new Date(now);
+          end.setDate(end.getDate() - 90);
+          const start = new Date(end);
+          start.setDate(start.getDate() - 90);
+          return {
+            start: this.getDayBounds(start).start,
+            end: this.getDayBounds(end).end
+          };
+        }
+        default:
+          throw new Error(`Unsupported time period: ${period}`);
+      }
+    } catch (error) {
+      console.error('Error in getPreviousPeriod:', error);
+      throw error;
+    }
+  }
+
+  getCurrentBusinessDayEnd() {
+    try {
+      const now = new Date();
+      const todayBounds = this.getDayBounds(now);
+      
+      // If current time is before day start (1 AM ET / 6 AM UTC),
+      // then we're still in yesterday's business day
+      const todayStart = new Date(Date.UTC(
+        now.getUTCFullYear(),
+        now.getUTCMonth(),
+        now.getUTCDate(),
+        this.dayStartsAt + 5,
+        0,
+        0,
+        0
+      ));
+
+      if (now < todayStart) {
+        const yesterdayBounds = this.getDayBounds(new Date(now.getTime() - 24 * 60 * 60 * 1000));
+        return yesterdayBounds.end;
+      }
+
+      // Return the earlier of current time or today's end
+      return now < todayBounds.end ? now : todayBounds.end;
+    } catch (error) {
+      console.error('Error in getCurrentBusinessDayEnd:', error);
+      return new Date();
+    }
+  }
+
+  isValidTimeRange(timeRange) {
+    return TimeManager.ALLOWED_RANGES.includes(timeRange);
+  }
+
+  isToday(date) {
+    const now = new Date();
+    const targetDate = new Date(date);
+    return (
+      targetDate.getUTCFullYear() === now.getUTCFullYear() &&
+      targetDate.getUTCMonth() === now.getUTCMonth() &&
+      targetDate.getUTCDate() === now.getUTCDate()
+    );
+  }
+
+  formatDate(date) {
+    try {
+      return date.toLocaleString('en-US', {
+        timeZone: this.timezone,
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit'
+      });
+    } catch (error) {
+      console.error('Error formatting date:', error);
+      return date.toISOString();
+    }
+  }
+}
+
+export const createTimeManager = (timezone, dayStartsAt) => new TimeManager(timezone, dayStartsAt); 

inventory-server/dashboard/auth-server/.env.example

@@ -0,0 +1,10 @@
+# Server Configuration
+NODE_ENV=development
+PORT=3003
+
+# Authentication
+JWT_SECRET=your-secret-key-here
+DASHBOARD_PASSWORD=your-dashboard-password-here
+
+# Cookie Settings
+COOKIE_DOMAIN=localhost # In production: .kent.pw 

inventory-server/dashboard/auth-server/index.js

@@ -0,0 +1,203 @@
+// auth-server/index.js
+const path = require('path');
+require('dotenv').config({ path: path.join(__dirname, '.env') });
+const express = require('express');
+const cors = require('cors');
+const cookieParser = require('cookie-parser');
+const jwt = require('jsonwebtoken');
+
+// Debug environment variables
+console.log('Environment variables loaded from:', path.join(__dirname, '.env'));
+console.log('Current directory:', __dirname);
+console.log('Available env vars:', Object.keys(process.env));
+
+const app = express();
+const PORT = process.env.PORT || 3003;
+const JWT_SECRET = process.env.JWT_SECRET;
+const DASHBOARD_PASSWORD = process.env.DASHBOARD_PASSWORD;
+
+// Validate required environment variables
+if (!JWT_SECRET || !DASHBOARD_PASSWORD) {
+  console.error('Missing required environment variables:');
+  if (!JWT_SECRET) console.error('- JWT_SECRET');
+  if (!DASHBOARD_PASSWORD) console.error('- DASHBOARD_PASSWORD');
+  process.exit(1);
+}
+
+// Middleware
+app.use(express.json());
+app.use(cookieParser());
+
+// Configure CORS
+const corsOptions = {
+  origin: function(origin, callback) {
+    const allowedOrigins = [
+      'http://localhost:3000',
+      'https://dashboard.kent.pw'
+    ];
+    
+    console.log('CORS check for origin:', origin);
+    
+    // Allow local network IPs (192.168.1.xxx)
+    if (origin && origin.match(/^http:\/\/192\.168\.1\.\d{1,3}(:\d+)?$/)) {
+      callback(null, true);
+      return;
+    }
+    
+    // Check if origin is in allowed list
+    if (!origin || allowedOrigins.indexOf(origin) !== -1) {
+      callback(null, true);
+    } else {
+      callback(new Error('Not allowed by CORS'));
+    }
+  },
+  credentials: true,
+  methods: ['GET', 'POST', 'OPTIONS'],
+  allowedHeaders: ['Content-Type', 'Authorization', 'Cookie', 'Accept'],
+  exposedHeaders: ['Set-Cookie']
+};
+
+app.use(cors(corsOptions));
+app.options('*', cors(corsOptions));
+
+// Debug logging
+app.use((req, res, next) => {
+  console.log(`${new Date().toISOString()} ${req.method} ${req.url}`);
+  console.log('Headers:', req.headers);
+  console.log('Cookies:', req.cookies);
+  next();
+});
+
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ 
+    status: 'ok',
+    timestamp: new Date().toISOString()
+  });
+});
+
+// Auth endpoints
+app.post('/login', (req, res) => {
+  console.log('Login attempt received');
+  console.log('Request body:', req.body);
+  console.log('Origin:', req.headers.origin);
+  
+  const { password } = req.body;
+  
+  if (!password) {
+    console.log('No password provided');
+    return res.status(400).json({
+      success: false,
+      message: 'Password is required'
+    });
+  }
+
+  console.log('Comparing passwords...');
+  console.log('Provided password length:', password.length);
+  console.log('Expected password length:', DASHBOARD_PASSWORD.length);
+  
+  if (password === DASHBOARD_PASSWORD) {
+    console.log('Password matched');
+    const token = jwt.sign({ authorized: true }, JWT_SECRET, {
+      expiresIn: '24h'
+    });
+
+    // Determine if request is from local network
+    const isLocalNetwork = req.headers.origin?.includes('192.168.1.') || req.headers.origin?.includes('localhost');
+    
+    const cookieOptions = {
+      httpOnly: true,
+      secure: !isLocalNetwork, // Only use secure for non-local requests
+      sameSite: isLocalNetwork ? 'lax' : 'none',
+      path: '/',
+      maxAge: 24 * 60 * 60 * 1000 // 24 hours
+    };
+
+    // Only set domain for production
+    if (!isLocalNetwork) {
+      cookieOptions.domain = '.kent.pw';
+    }
+
+    console.log('Setting cookie with options:', cookieOptions);
+    res.cookie('token', token, cookieOptions);
+    
+    console.log('Response headers:', res.getHeaders());
+    res.json({ 
+      success: true,
+      debug: { 
+        origin: req.headers.origin,
+        cookieOptions 
+      }
+    });
+  } else {
+    console.log('Password mismatch');
+    res.status(401).json({
+      success: false,
+      message: 'Invalid password'
+    });
+  }
+});
+
+// Modify the check endpoint to log more info
+app.get('/check', (req, res) => {
+  console.log('Auth check received');
+  console.log('All cookies:', req.cookies);
+  console.log('Headers:', req.headers);
+  
+  const token = req.cookies.token;
+  
+  if (!token) {
+    console.log('No token found in cookies');
+    return res.status(401).json({ 
+      authenticated: false,
+      error: 'no_token' 
+    });
+  }
+
+  try {
+    const decoded = jwt.verify(token, JWT_SECRET);
+    console.log('Token verified successfully:', decoded);
+    res.json({ authenticated: true });
+  } catch (err) {
+    console.log('Token verification failed:', err.message);
+    res.status(401).json({ 
+      authenticated: false,
+      error: 'invalid_token',
+      message: err.message
+    });
+  }
+});
+
+app.post('/logout', (req, res) => {
+  const isLocalNetwork = req.headers.origin?.includes('192.168.1.') || req.headers.origin?.includes('localhost');
+  const cookieOptions = {
+    httpOnly: true,
+    secure: !isLocalNetwork,
+    sameSite: isLocalNetwork ? 'lax' : 'none',
+    path: '/',
+    domain: isLocalNetwork ? undefined : '.kent.pw'
+  };
+  
+  console.log('Clearing cookie with options:', cookieOptions);
+  res.clearCookie('token', cookieOptions);
+  res.json({ success: true });
+});
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error('Server error:', err);
+  res.status(500).json({ 
+    success: false, 
+    message: 'Internal server error',
+    error: err.message 
+  });
+});
+
+// Start server
+app.listen(PORT, () => {
+  console.log(`Auth server running on port ${PORT}`);
+  console.log('Environment:', process.env.NODE_ENV);
+  console.log('CORS origins:', corsOptions.origin);
+  console.log('JWT_SECRET length:', JWT_SECRET?.length);
+  console.log('DASHBOARD_PASSWORD length:', DASHBOARD_PASSWORD?.length);
+});

inventory-server/dashboard/auth-server/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "auth-server",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "cookie-parser": "^1.4.7",
+    "cors": "^2.8.5",
+    "date-fns": "^4.1.0",
+    "date-fns-tz": "^3.2.0",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.1",
+    "express-session": "^1.18.1",
+    "jsonwebtoken": "^9.0.2"
+  }
+}

inventory-server/dashboard/dashboard.conf

@@ -0,0 +1 @@
+/etc/nginx/sites-enabled/dashboard.conf

inventory-server/dashboard/google-server/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "google-analytics-server",
+  "version": "1.0.0",
+  "description": "Google Analytics server for dashboard",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "@google-analytics/data": "^4.0.0",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "redis": "^4.6.11",
+    "winston": "^3.11.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  }
+}

inventory-server/dashboard/google-server/routes/analytics.js

@@ -0,0 +1,254 @@
+const express = require('express');
+const { BetaAnalyticsDataClient } = require('@google-analytics/data');
+const router = express.Router();
+const logger = require('../utils/logger');
+
+// Initialize GA4 client
+const analyticsClient = new BetaAnalyticsDataClient({
+  credentials: JSON.parse(process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON)
+});
+
+const propertyId = process.env.GA_PROPERTY_ID;
+
+// Cache durations
+const CACHE_DURATIONS = {
+  REALTIME_BASIC: 60, // 1 minute
+  REALTIME_DETAILED: 300, // 5 minutes
+  BASIC_METRICS: 3600, // 1 hour
+  USER_BEHAVIOR: 3600 // 1 hour
+};
+
+// Basic metrics endpoint
+router.get('/metrics', async (req, res) => {
+  try {
+    const { startDate = '7daysAgo' } = req.query;
+    const cacheKey = `analytics:basic_metrics:${startDate}`;
+
+    // Check Redis cache
+    const cachedData = await req.redisClient.get(cacheKey);
+    if (cachedData) {
+      logger.info('Returning cached basic metrics data');
+      return res.json({ success: true, data: JSON.parse(cachedData) });
+    }
+
+    // Fetch from GA4
+    const [response] = await analyticsClient.runReport({
+      property: `properties/${propertyId}`,
+      dateRanges: [{ startDate, endDate: 'today' }],
+      dimensions: [{ name: 'date' }],
+      metrics: [
+        { name: 'activeUsers' },
+        { name: 'newUsers' },
+        { name: 'averageSessionDuration' },
+        { name: 'screenPageViews' },
+        { name: 'bounceRate' },
+        { name: 'conversions' }
+      ],
+      returnPropertyQuota: true
+    });
+
+    // Cache the response
+    await req.redisClient.set(cacheKey, JSON.stringify(response), {
+      EX: CACHE_DURATIONS.BASIC_METRICS
+    });
+
+    res.json({ success: true, data: response });
+  } catch (error) {
+    logger.error('Error fetching basic metrics:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Realtime basic data endpoint
+router.get('/realtime/basic', async (req, res) => {
+  try {
+    const cacheKey = 'analytics:realtime:basic';
+    
+    // Check Redis cache
+    const cachedData = await req.redisClient.get(cacheKey);
+    if (cachedData) {
+      logger.info('Returning cached realtime basic data');
+      return res.json({ success: true, data: JSON.parse(cachedData) });
+    }
+
+    // Fetch active users
+    const [userResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      metrics: [{ name: 'activeUsers' }],
+      returnPropertyQuota: true
+    });
+
+    // Fetch last 5 minutes
+    const [fiveMinResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      metrics: [{ name: 'activeUsers' }],
+      minuteRanges: [{ startMinutesAgo: 5, endMinutesAgo: 0 }]
+    });
+
+    // Fetch time series data
+    const [timeSeriesResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      dimensions: [{ name: 'minutesAgo' }],
+      metrics: [{ name: 'activeUsers' }]
+    });
+
+    const response = {
+      userResponse,
+      fiveMinResponse,
+      timeSeriesResponse,
+      quotaInfo: {
+        projectHourly: userResponse.propertyQuota.tokensPerProjectPerHour,
+        daily: userResponse.propertyQuota.tokensPerDay,
+        serverErrors: userResponse.propertyQuota.serverErrorsPerProjectPerHour,
+        thresholdedRequests: userResponse.propertyQuota.potentiallyThresholdedRequestsPerHour
+      }
+    };
+
+    // Cache the response
+    await req.redisClient.set(cacheKey, JSON.stringify(response), {
+      EX: CACHE_DURATIONS.REALTIME_BASIC
+    });
+
+    res.json({ success: true, data: response });
+  } catch (error) {
+    logger.error('Error fetching realtime basic data:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// Realtime detailed data endpoint
+router.get('/realtime/detailed', async (req, res) => {
+  try {
+    const cacheKey = 'analytics:realtime:detailed';
+    
+    // Check Redis cache
+    const cachedData = await req.redisClient.get(cacheKey);
+    if (cachedData) {
+      logger.info('Returning cached realtime detailed data');
+      return res.json({ success: true, data: JSON.parse(cachedData) });
+    }
+
+    // Fetch current pages
+    const [pageResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      dimensions: [{ name: 'unifiedScreenName' }],
+      metrics: [{ name: 'screenPageViews' }],
+      orderBy: [{ metric: { metricName: 'screenPageViews' }, desc: true }],
+      limit: 25
+    });
+
+    // Fetch events
+    const [eventResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      dimensions: [{ name: 'eventName' }],
+      metrics: [{ name: 'eventCount' }],
+      orderBy: [{ metric: { metricName: 'eventCount' }, desc: true }],
+      limit: 25
+    });
+
+    // Fetch device categories
+    const [deviceResponse] = await analyticsClient.runRealtimeReport({
+      property: `properties/${propertyId}`,
+      dimensions: [{ name: 'deviceCategory' }],
+      metrics: [{ name: 'activeUsers' }],
+      orderBy: [{ metric: { metricName: 'activeUsers' }, desc: true }],
+      limit: 10,
+      returnPropertyQuota: true
+    });
+
+    const response = {
+      pageResponse,
+      eventResponse,
+      sourceResponse: deviceResponse
+    };
+
+    // Cache the response
+    await req.redisClient.set(cacheKey, JSON.stringify(response), {
+      EX: CACHE_DURATIONS.REALTIME_DETAILED
+    });
+
+    res.json({ success: true, data: response });
+  } catch (error) {
+    logger.error('Error fetching realtime detailed data:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+// User behavior endpoint
+router.get('/user-behavior', async (req, res) => {
+  try {
+    const { timeRange = '30' } = req.query;
+    const cacheKey = `analytics:user_behavior:${timeRange}`;
+    
+    // Check Redis cache
+    const cachedData = await req.redisClient.get(cacheKey);
+    if (cachedData) {
+      logger.info('Returning cached user behavior data');
+      return res.json({ success: true, data: JSON.parse(cachedData) });
+    }
+
+    // Fetch page data
+    const [pageResponse] = await analyticsClient.runReport({
+      property: `properties/${propertyId}`,
+      dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+      dimensions: [{ name: 'pagePath' }],
+      metrics: [
+        { name: 'screenPageViews' },
+        { name: 'averageSessionDuration' },
+        { name: 'bounceRate' },
+        { name: 'sessions' }
+      ],
+      orderBy: [{
+        metric: { metricName: 'screenPageViews' },
+        desc: true
+      }],
+      limit: 25
+    });
+
+    // Fetch device data
+    const [deviceResponse] = await analyticsClient.runReport({
+      property: `properties/${propertyId}`,
+      dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+      dimensions: [{ name: 'deviceCategory' }],
+      metrics: [
+        { name: 'screenPageViews' },
+        { name: 'sessions' }
+      ]
+    });
+
+    // Fetch source data
+    const [sourceResponse] = await analyticsClient.runReport({
+      property: `properties/${propertyId}`,
+      dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+      dimensions: [{ name: 'sessionSource' }],
+      metrics: [
+        { name: 'sessions' },
+        { name: 'conversions' }
+      ],
+      orderBy: [{
+        metric: { metricName: 'sessions' },
+        desc: true
+      }],
+      limit: 25,
+      returnPropertyQuota: true
+    });
+
+    const response = {
+      pageResponse,
+      deviceResponse,
+      sourceResponse
+    };
+
+    // Cache the response
+    await req.redisClient.set(cacheKey, JSON.stringify(response), {
+      EX: CACHE_DURATIONS.USER_BEHAVIOR
+    });
+
+    res.json({ success: true, data: response });
+  } catch (error) {
+    logger.error('Error fetching user behavior data:', error);
+    res.status(500).json({ success: false, error: error.message });
+  }
+});
+
+module.exports = router; 

inventory-server/dashboard/google-server/routes/analytics.routes.js

@@ -0,0 +1,91 @@
+const express = require('express');
+const router = express.Router();
+const analyticsService = require('../services/analytics.service');
+
+// Basic metrics endpoint
+router.get('/metrics', async (req, res) => {
+  try {
+    const { startDate = '7daysAgo' } = req.query;
+    console.log(`Fetching metrics with startDate: ${startDate}`);
+    
+    const data = await analyticsService.getBasicMetrics(startDate);
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('Metrics error:', {
+      startDate: req.query.startDate,
+      error: error.message,
+      stack: error.stack
+    });
+    
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch metrics',
+      details: error.message
+    });
+  }
+});
+
+// Realtime basic data endpoint
+router.get('/realtime/basic', async (req, res) => {
+  try {
+    console.log('Fetching realtime basic data');
+    const data = await analyticsService.getRealTimeBasicData();
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('Realtime basic error:', {
+      error: error.message,
+      stack: error.stack
+    });
+    
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch realtime basic data',
+      details: error.message
+    });
+  }
+});
+
+// Realtime detailed data endpoint
+router.get('/realtime/detailed', async (req, res) => {
+  try {
+    console.log('Fetching realtime detailed data');
+    const data = await analyticsService.getRealTimeDetailedData();
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('Realtime detailed error:', {
+      error: error.message,
+      stack: error.stack
+    });
+    
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch realtime detailed data',
+      details: error.message
+    });
+  }
+});
+
+// User behavior endpoint
+router.get('/user-behavior', async (req, res) => {
+  try {
+    const { timeRange = '30' } = req.query;
+    console.log(`Fetching user behavior with timeRange: ${timeRange}`);
+    
+    const data = await analyticsService.getUserBehavior(timeRange);
+    res.json({ success: true, data });
+  } catch (error) {
+    console.error('User behavior error:', {
+      timeRange: req.query.timeRange,
+      error: error.message,
+      stack: error.stack
+    });
+    
+    res.status(500).json({
+      success: false,
+      error: 'Failed to fetch user behavior data',
+      details: error.message
+    });
+  }
+});
+
+module.exports = router; 

inventory-server/dashboard/google-server/server.js

@@ -0,0 +1,65 @@
+const express = require('express');
+const cors = require('cors');
+const { createClient } = require('redis');
+const analyticsRoutes = require('./routes/analytics.routes');
+
+const app = express();
+const port = process.env.GOOGLE_ANALYTICS_PORT || 3007;
+
+// Redis client setup
+const redisClient = createClient({
+  url: process.env.REDIS_URL || 'redis://localhost:6379'
+});
+
+redisClient.on('error', (err) => console.error('Redis Client Error:', err));
+redisClient.on('connect', () => console.log('Redis Client Connected'));
+
+// Connect to Redis
+(async () => {
+  try {
+    await redisClient.connect();
+  } catch (err) {
+    console.error('Redis connection error:', err);
+  }
+})();
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Make Redis client available in requests
+app.use((req, res, next) => {
+  req.redisClient = redisClient;
+  next();
+});
+
+// Routes
+app.use('/api/analytics', analyticsRoutes);
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error('Server error:', err);
+  res.status(err.status || 500).json({
+    success: false,
+    message: err.message || 'Internal server error',
+    error: process.env.NODE_ENV === 'production' ? err : {}
+  });
+});
+
+// Start server
+app.listen(port, () => {
+  console.log(`Google Analytics server running on port ${port}`);
+});
+
+// Handle graceful shutdown
+process.on('SIGTERM', async () => {
+  console.log('SIGTERM received. Shutting down gracefully...');
+  await redisClient.quit();
+  process.exit(0);
+});
+
+process.on('SIGINT', async () => {
+  console.log('SIGINT received. Shutting down gracefully...');
+  await redisClient.quit();
+  process.exit(0);
+}); 

inventory-server/dashboard/google-server/services/analytics.service.js

@@ -0,0 +1,283 @@
+const { BetaAnalyticsDataClient } = require('@google-analytics/data');
+const { createClient } = require('redis');
+
+class AnalyticsService {
+  constructor() {
+    // Initialize Redis client
+    this.redis = createClient({
+      url: process.env.REDIS_URL || 'redis://localhost:6379'
+    });
+    
+    this.redis.on('error', err => console.error('Redis Client Error:', err));
+    this.redis.connect().catch(err => console.error('Redis connection error:', err));
+
+    try {
+      // Initialize GA4 client
+      const credentials = process.env.GOOGLE_APPLICATION_CREDENTIALS_JSON;
+      this.analyticsClient = new BetaAnalyticsDataClient({
+        credentials: typeof credentials === 'string' ? JSON.parse(credentials) : credentials
+      });
+      
+      this.propertyId = process.env.GA_PROPERTY_ID;
+    } catch (error) {
+      console.error('Failed to initialize GA4 client:', error);
+      throw error;
+    }
+  }
+
+  // Cache durations
+  CACHE_DURATIONS = {
+    REALTIME_BASIC: 60, // 1 minute
+    REALTIME_DETAILED: 300, // 5 minutes
+    BASIC_METRICS: 3600, // 1 hour
+    USER_BEHAVIOR: 3600 // 1 hour
+  };
+
+  async getBasicMetrics(startDate = '7daysAgo') {
+    const cacheKey = `analytics:basic_metrics:${startDate}`;
+    
+    try {
+      // Try Redis first
+      const cachedData = await this.redis.get(cacheKey);
+      if (cachedData) {
+        console.log('Analytics metrics found in Redis cache');
+        return JSON.parse(cachedData);
+      }
+
+      // Fetch from GA4
+      console.log('Fetching fresh metrics data from GA4');
+      const [response] = await this.analyticsClient.runReport({
+        property: `properties/${this.propertyId}`,
+        dateRanges: [{ startDate, endDate: 'today' }],
+        dimensions: [{ name: 'date' }],
+        metrics: [
+          { name: 'activeUsers' },
+          { name: 'newUsers' },
+          { name: 'averageSessionDuration' },
+          { name: 'screenPageViews' },
+          { name: 'bounceRate' },
+          { name: 'conversions' }
+        ],
+        returnPropertyQuota: true
+      });
+
+      // Cache the response
+      await this.redis.set(cacheKey, JSON.stringify(response), {
+        EX: this.CACHE_DURATIONS.BASIC_METRICS
+      });
+
+      return response;
+    } catch (error) {
+      console.error('Error fetching analytics metrics:', {
+        error: error.message,
+        stack: error.stack
+      });
+      throw error;
+    }
+  }
+
+  async getRealTimeBasicData() {
+    const cacheKey = 'analytics:realtime:basic';
+    
+    try {
+      // Try Redis first
+      const cachedData = await this.redis.get(cacheKey);
+      if (cachedData) {
+        console.log('Realtime basic data found in Redis cache');
+        return JSON.parse(cachedData);
+      }
+
+      console.log('Fetching fresh realtime data from GA4');
+      
+      // Fetch active users
+      const [userResponse] = await this.analyticsClient.runRealtimeReport({
+        property: `properties/${this.propertyId}`,
+        metrics: [{ name: 'activeUsers' }],
+        returnPropertyQuota: true
+      });
+
+      // Fetch last 5 minutes
+      const [fiveMinResponse] = await this.analyticsClient.runRealtimeReport({
+        property: `properties/${this.propertyId}`,
+        metrics: [{ name: 'activeUsers' }],
+        minuteRanges: [{ startMinutesAgo: 5, endMinutesAgo: 0 }]
+      });
+
+      // Fetch time series data
+      const [timeSeriesResponse] = await this.analyticsClient.runRealtimeReport({
+        property: `properties/${this.propertyId}`,
+        dimensions: [{ name: 'minutesAgo' }],
+        metrics: [{ name: 'activeUsers' }]
+      });
+
+      const response = {
+        userResponse,
+        fiveMinResponse,
+        timeSeriesResponse,
+        quotaInfo: {
+          projectHourly: userResponse.propertyQuota.tokensPerProjectPerHour,
+          daily: userResponse.propertyQuota.tokensPerDay,
+          serverErrors: userResponse.propertyQuota.serverErrorsPerProjectPerHour,
+          thresholdedRequests: userResponse.propertyQuota.potentiallyThresholdedRequestsPerHour
+        }
+      };
+
+      // Cache the response
+      await this.redis.set(cacheKey, JSON.stringify(response), {
+        EX: this.CACHE_DURATIONS.REALTIME_BASIC
+      });
+
+      return response;
+    } catch (error) {
+      console.error('Error fetching realtime basic data:', {
+        error: error.message,
+        stack: error.stack
+      });
+      throw error;
+    }
+  }
+
+  async getRealTimeDetailedData() {
+    const cacheKey = 'analytics:realtime:detailed';
+    
+    try {
+      // Try Redis first
+      const cachedData = await this.redis.get(cacheKey);
+      if (cachedData) {
+        console.log('Realtime detailed data found in Redis cache');
+        return JSON.parse(cachedData);
+      }
+
+      console.log('Fetching fresh realtime detailed data from GA4');
+
+      // Fetch current pages
+      const [pageResponse] = await this.analyticsClient.runRealtimeReport({
+        property: `properties/${this.propertyId}`,
+        dimensions: [{ name: 'unifiedScreenName' }],
+        metrics: [{ name: 'screenPageViews' }],
+        orderBy: [{ metric: { metricName: 'screenPageViews' }, desc: true }],
+        limit: 25
+      });
+
+      // Fetch events
+      const [eventResponse] = await this.analyticsClient.runRealtimeReport({
+        property: `properties/${this.propertyId}`,
+        dimensions: [{ name: 'eventName' }],
+        metrics: [{ name: 'eventCount' }],
+        orderBy: [{ metric: { metricName: 'eventCount' }, desc: true }],
+        limit: 25
+      });
+
+      // Fetch device categories
+      const [deviceResponse] = await this.analyticsClient.runRealtimeReport({
+        property: `properties/${this.propertyId}`,
+        dimensions: [{ name: 'deviceCategory' }],
+        metrics: [{ name: 'activeUsers' }],
+        orderBy: [{ metric: { metricName: 'activeUsers' }, desc: true }],
+        limit: 10,
+        returnPropertyQuota: true
+      });
+
+      const response = {
+        pageResponse,
+        eventResponse,
+        sourceResponse: deviceResponse
+      };
+
+      // Cache the response
+      await this.redis.set(cacheKey, JSON.stringify(response), {
+        EX: this.CACHE_DURATIONS.REALTIME_DETAILED
+      });
+
+      return response;
+    } catch (error) {
+      console.error('Error fetching realtime detailed data:', {
+        error: error.message,
+        stack: error.stack
+      });
+      throw error;
+    }
+  }
+
+  async getUserBehavior(timeRange = '30') {
+    const cacheKey = `analytics:user_behavior:${timeRange}`;
+    
+    try {
+      // Try Redis first
+      const cachedData = await this.redis.get(cacheKey);
+      if (cachedData) {
+        console.log('User behavior data found in Redis cache');
+        return JSON.parse(cachedData);
+      }
+
+      console.log('Fetching fresh user behavior data from GA4');
+
+      // Fetch page data
+      const [pageResponse] = await this.analyticsClient.runReport({
+        property: `properties/${this.propertyId}`,
+        dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+        dimensions: [{ name: 'pagePath' }],
+        metrics: [
+          { name: 'screenPageViews' },
+          { name: 'averageSessionDuration' },
+          { name: 'bounceRate' },
+          { name: 'sessions' }
+        ],
+        orderBy: [{
+          metric: { metricName: 'screenPageViews' },
+          desc: true
+        }],
+        limit: 25
+      });
+
+      // Fetch device data
+      const [deviceResponse] = await this.analyticsClient.runReport({
+        property: `properties/${this.propertyId}`,
+        dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+        dimensions: [{ name: 'deviceCategory' }],
+        metrics: [
+          { name: 'screenPageViews' },
+          { name: 'sessions' }
+        ]
+      });
+
+      // Fetch source data
+      const [sourceResponse] = await this.analyticsClient.runReport({
+        property: `properties/${this.propertyId}`,
+        dateRanges: [{ startDate: `${timeRange}daysAgo`, endDate: 'today' }],
+        dimensions: [{ name: 'sessionSource' }],
+        metrics: [
+          { name: 'sessions' },
+          { name: 'conversions' }
+        ],
+        orderBy: [{
+          metric: { metricName: 'sessions' },
+          desc: true
+        }],
+        limit: 25,
+        returnPropertyQuota: true
+      });
+
+      const response = {
+        pageResponse,
+        deviceResponse,
+        sourceResponse
+      };
+
+      // Cache the response
+      await this.redis.set(cacheKey, JSON.stringify(response), {
+        EX: this.CACHE_DURATIONS.USER_BEHAVIOR
+      });
+
+      return response;
+    } catch (error) {
+      console.error('Error fetching user behavior data:', {
+        error: error.message,
+        stack: error.stack
+      });
+      throw error;
+    }
+  }
+}
+
+module.exports = new AnalyticsService(); 

inventory-server/dashboard/google-server/utils/logger.js

@@ -0,0 +1,35 @@
+const winston = require('winston');
+const path = require('path');
+
+const logger = winston.createLogger({
+  level: process.env.LOG_LEVEL || 'info',
+  format: winston.format.combine(
+    winston.format.timestamp(),
+    winston.format.json()
+  ),
+  transports: [
+    new winston.transports.File({
+      filename: path.join(__dirname, '../logs/pm2/error.log'),
+      level: 'error',
+      maxsize: 10485760, // 10MB
+      maxFiles: 5
+    }),
+    new winston.transports.File({
+      filename: path.join(__dirname, '../logs/pm2/combined.log'),
+      maxsize: 10485760, // 10MB
+      maxFiles: 5
+    })
+  ]
+});
+
+// Add console transport in development
+if (process.env.NODE_ENV !== 'production') {
+  logger.add(new winston.transports.Console({
+    format: winston.format.combine(
+      winston.format.colorize(),
+      winston.format.simple()
+    )
+  }));
+}
+
+module.exports = logger; 

inventory-server/dashboard/gorgias-server/package.json

@@ -0,0 +1,19 @@
+{
+  "name": "gorgias-server",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "axios": "^1.7.9",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2",
+    "redis": "^4.7.0"
+  }
+}

inventory-server/dashboard/gorgias-server/routes/gorgias.routes.js

@@ -0,0 +1,119 @@
+const express = require('express');
+const router = express.Router();
+const gorgiasService = require('../services/gorgias.service');
+
+// Get statistics
+router.post('/stats/:name', async (req, res) => {
+  try {
+    const { name } = req.params;
+    const filters = req.body;
+    
+    console.log(`Fetching ${name} statistics with filters:`, filters);
+    
+    if (!name) {
+      return res.status(400).json({
+        error: 'Missing statistic name',
+        details: 'The name parameter is required'
+      });
+    }
+
+    const data = await gorgiasService.getStatistics(name, filters);
+    
+    if (!data) {
+      return res.status(404).json({
+        error: 'No data found',
+        details: `No statistics found for ${name}`
+      });
+    }
+
+    res.json({ data });
+  } catch (error) {
+    console.error('Statistics error:', {
+      name: req.params.name,
+      filters: req.body,
+      error: error.message,
+      stack: error.stack,
+      response: error.response?.data
+    });
+    
+    // Handle specific error cases
+    if (error.response?.status === 401) {
+      return res.status(401).json({
+        error: 'Authentication failed',
+        details: 'Invalid Gorgias API credentials'
+      });
+    }
+    
+    if (error.response?.status === 404) {
+      return res.status(404).json({
+        error: 'Not found',
+        details: `Statistics type '${req.params.name}' not found`
+      });
+    }
+
+    if (error.response?.status === 400) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        details: error.response?.data?.message || 'The request was invalid',
+        data: error.response?.data
+      });
+    }
+    
+    res.status(500).json({
+      error: 'Failed to fetch statistics',
+      details: error.response?.data?.message || error.message,
+      data: error.response?.data
+    });
+  }
+});
+
+// Get tickets
+router.get('/tickets', async (req, res) => {
+  try {
+    const data = await gorgiasService.getTickets(req.query);
+    res.json(data);
+  } catch (error) {
+    console.error('Tickets error:', {
+      params: req.query,
+      error: error.message,
+      response: error.response?.data
+    });
+
+    if (error.response?.status === 401) {
+      return res.status(401).json({
+        error: 'Authentication failed',
+        details: 'Invalid Gorgias API credentials'
+      });
+    }
+
+    if (error.response?.status === 400) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        details: error.response?.data?.message || 'The request was invalid',
+        data: error.response?.data
+      });
+    }
+
+    res.status(500).json({
+      error: 'Failed to fetch tickets',
+      details: error.response?.data?.message || error.message,
+      data: error.response?.data
+    });
+  }
+});
+
+// Get customer satisfaction
+router.get('/satisfaction', async (req, res) => {
+  try {
+    const data = await gorgiasService.getCustomerSatisfaction(req.query);
+    res.json(data);
+  } catch (error) {
+    console.error('Satisfaction error:', error);
+    res.status(500).json({
+      error: 'Failed to fetch customer satisfaction',
+      details: error.response?.data || error.message
+    });
+  }
+});
+
+module.exports = router; 

inventory-server/dashboard/gorgias-server/server.js

@@ -0,0 +1,31 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+require('dotenv').config({ 
+  path: path.resolve(__dirname, '.env') 
+});
+
+const app = express();
+const port = process.env.PORT || 3006;
+
+app.use(cors());
+app.use(express.json());
+
+// Import routes
+const gorgiasRoutes = require('./routes/gorgias.routes');
+
+// Use routes
+app.use('/api/gorgias', gorgiasRoutes);
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).json({ error: 'Something went wrong!' });
+});
+
+// Start server
+app.listen(port, () => {
+  console.log(`Gorgias API server running on port ${port}`);
+});
+
+module.exports = app;

inventory-server/dashboard/gorgias-server/services/gorgias.service.js

@@ -0,0 +1,119 @@
+const axios = require('axios');
+const { createClient } = require('redis');
+
+class GorgiasService {
+  constructor() {
+    this.redis = createClient({
+      url: process.env.REDIS_URL
+    });
+    
+    this.redis.on('error', err => console.error('Redis Client Error:', err));
+    this.redis.connect().catch(err => console.error('Redis connection error:', err));
+    
+    // Create base64 encoded auth string
+    const auth = Buffer.from(`${process.env.GORGIAS_API_USERNAME}:${process.env.GORGIAS_API_KEY}`).toString('base64');
+    
+    this.apiClient = axios.create({
+      baseURL: `https://${process.env.GORGIAS_DOMAIN}.gorgias.com/api`,
+      headers: {
+        'Authorization': `Basic ${auth}`,
+        'Content-Type': 'application/json'
+      }
+    });
+  }
+
+  async getStatistics(name, filters = {}) {
+    const cacheKey = `gorgias:stats:${name}:${JSON.stringify(filters)}`;
+    
+    try {
+      // Try Redis first
+      const cachedData = await this.redis.get(cacheKey);
+      if (cachedData) {
+        console.log(`Statistics ${name} found in Redis cache`);
+        return JSON.parse(cachedData);
+      }
+
+      console.log(`Fetching ${name} statistics with filters:`, filters);
+
+      // Convert dates to UTC midnight if not already set
+      if (!filters.start_datetime || !filters.end_datetime) {
+        const start = new Date(filters.start_datetime || filters.start_date);
+        start.setUTCHours(0, 0, 0, 0);
+        const end = new Date(filters.end_datetime || filters.end_date);
+        end.setUTCHours(23, 59, 59, 999);
+
+        filters = {
+          ...filters,
+          start_datetime: start.toISOString(),
+          end_datetime: end.toISOString()
+        };
+      }
+
+      // Fetch from API
+      const response = await this.apiClient.post(`/stats/${name}`, filters);
+      const data = response.data;
+
+      // Save to Redis with 5 minute expiry
+      await this.redis.set(cacheKey, JSON.stringify(data), {
+        EX: 300 // 5 minutes
+      });
+
+      return data;
+    } catch (error) {
+      console.error(`Error in getStatistics for ${name}:`, {
+        error: error.message,
+        filters,
+        response: error.response?.data
+      });
+      throw error;
+    }
+  }
+
+  async getTickets(params = {}) {
+    const cacheKey = `gorgias:tickets:${JSON.stringify(params)}`;
+    
+    try {
+      // Try Redis first
+      const cachedData = await this.redis.get(cacheKey);
+      if (cachedData) {
+        console.log('Tickets found in Redis cache');
+        return JSON.parse(cachedData);
+      }
+
+      // Convert dates to UTC midnight
+      const formattedParams = { ...params };
+      if (params.start_date) {
+        const start = new Date(params.start_date);
+        start.setUTCHours(0, 0, 0, 0);
+        formattedParams.start_datetime = start.toISOString();
+        delete formattedParams.start_date;
+      }
+      if (params.end_date) {
+        const end = new Date(params.end_date);
+        end.setUTCHours(23, 59, 59, 999);
+        formattedParams.end_datetime = end.toISOString();
+        delete formattedParams.end_date;
+      }
+
+      // Fetch from API
+      const response = await this.apiClient.get('/tickets', { params: formattedParams });
+      const data = response.data;
+
+      // Save to Redis with 5 minute expiry
+      await this.redis.set(cacheKey, JSON.stringify(data), {
+        EX: 300 // 5 minutes
+      });
+
+      return data;
+    } catch (error) {
+      console.error('Error fetching tickets:', {
+        error: error.message,
+        params,
+        response: error.response?.data
+      });
+      throw error;
+    }
+  }
+}
+
+module.exports = new GorgiasService(); 

inventory-server/dashboard/klaviyo-server/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "klaviyo-server",
+  "version": "1.0.0",
+  "description": "Klaviyo API integration server",
+  "main": "server.js",
+  "type": "module",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "esm": "^3.2.25",
+    "express": "^4.18.2",
+    "express-rate-limit": "^7.5.0",
+    "ioredis": "^5.4.1",
+    "luxon": "^3.5.0",
+    "node-fetch": "^3.3.2",
+    "recharts": "^2.15.0"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  }
+}

inventory-server/dashboard/klaviyo-server/routes/campaigns.routes.js

@@ -0,0 +1,71 @@
+import express from 'express';
+import { CampaignsService } from '../services/campaigns.service.js';
+import { TimeManager } from '../utils/time.utils.js';
+
+export function createCampaignsRouter(apiKey, apiRevision) {
+  const router = express.Router();
+  const timeManager = new TimeManager();
+  const campaignsService = new CampaignsService(apiKey, apiRevision);
+
+  // Get campaigns with optional filtering
+  router.get('/', async (req, res) => {
+    try {
+      const params = {
+        pageSize: parseInt(req.query.pageSize) || 50,
+        sort: req.query.sort || '-send_time',
+        status: req.query.status,
+        startDate: req.query.startDate,
+        endDate: req.query.endDate,
+        pageCursor: req.query.pageCursor
+      };
+
+      console.log('[Campaigns Route] Fetching campaigns with params:', params);
+      const data = await campaignsService.getCampaigns(params);
+      console.log('[Campaigns Route] Success:', {
+        count: data.data?.length || 0
+      });
+      res.json(data);
+    } catch (error) {
+      console.error('[Campaigns Route] Error:', error);
+      res.status(500).json({ 
+        status: 'error', 
+        message: error.message,
+        details: error.response?.data || null
+      });
+    }
+  });
+
+  // Get campaigns by time range
+  router.get('/:timeRange', async (req, res) => {
+    try {
+      const { timeRange } = req.params;
+      const { status } = req.query;
+
+      let result;
+      if (timeRange === 'custom') {
+        const { startDate, endDate } = req.query;
+        if (!startDate || !endDate) {
+          return res.status(400).json({ error: 'Custom range requires startDate and endDate' });
+        }
+
+        result = await campaignsService.getCampaigns({
+          startDate,
+          endDate,
+          status
+        });
+      } else {
+        result = await campaignsService.getCampaignsByTimeRange(
+          timeRange,
+          { status }
+        );
+      }
+
+      res.json(result);
+    } catch (error) {
+      console.error("[Campaigns Route] Error:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  return router;
+} 

inventory-server/dashboard/klaviyo-server/routes/events.routes.js

@@ -0,0 +1,480 @@
+import express from 'express';
+import { EventsService } from '../services/events.service.js';
+import { TimeManager } from '../utils/time.utils.js';
+import { RedisService } from '../services/redis.service.js';
+
+// Import METRIC_IDS from events service
+const METRIC_IDS = {
+  PLACED_ORDER: 'Y8cqcF',
+  SHIPPED_ORDER: 'VExpdL',
+  ACCOUNT_CREATED: 'TeeypV',
+  CANCELED_ORDER: 'YjVMNg',
+  NEW_BLOG_POST: 'YcxeDr',
+  PAYMENT_REFUNDED: 'R7XUYh'
+};
+
+export function createEventsRouter(apiKey, apiRevision) {
+  const router = express.Router();
+  const timeManager = new TimeManager();
+  const eventsService = new EventsService(apiKey, apiRevision);
+  const redisService = new RedisService();
+
+  // Get events with optional filtering
+  router.get('/', async (req, res) => {
+    try {
+      const params = {
+        pageSize: parseInt(req.query.pageSize) || 50,
+        sort: req.query.sort || '-datetime',
+        metricId: req.query.metricId,
+        startDate: req.query.startDate,
+        endDate: req.query.endDate,
+        pageCursor: req.query.pageCursor,
+        fields: {}
+      };
+
+      // Parse fields parameter if provided
+      if (req.query.fields) {
+        try {
+          params.fields = JSON.parse(req.query.fields);
+        } catch (e) {
+          console.warn('[Events Route] Invalid fields parameter:', e);
+        }
+      }
+
+      console.log('[Events Route] Fetching events with params:', params);
+      const data = await eventsService.getEvents(params);
+      console.log('[Events Route] Success:', {
+        count: data.data?.length || 0,
+        included: data.included?.length || 0
+      });
+      res.json(data);
+    } catch (error) {
+      console.error('[Events Route] Error:', error);
+      res.status(500).json({ 
+        status: 'error', 
+        message: error.message,
+        details: error.response?.data || null
+      });
+    }
+  });
+
+  // Get events by time range
+  router.get('/by-time/:timeRange', async (req, res) => {
+    try {
+      const { timeRange } = req.params;
+      const { metricId, startDate, endDate } = req.query;
+
+      let result;
+      if (timeRange === 'custom') {
+        if (!startDate || !endDate) {
+          return res.status(400).json({ error: 'Custom range requires startDate and endDate' });
+        }
+
+        const range = timeManager.getCustomRange(startDate, endDate);
+        if (!range) {
+          return res.status(400).json({ error: 'Invalid date range' });
+        }
+
+        result = await eventsService.getEvents({
+          metricId,
+          startDate: range.start.toISO(),
+          endDate: range.end.toISO()
+        });
+      } else {
+        result = await eventsService.getEventsByTimeRange(
+          timeRange,
+          { metricId }
+        );
+      }
+
+      res.json(result);
+    } catch (error) {
+      console.error("[Events Route] Error:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Get comprehensive statistics for a time period
+  router.get('/stats', async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate } = req.query;
+      console.log('[Events Route] Stats request:', {
+        timeRange,
+        startDate,
+        endDate
+      });
+
+      let range;
+      if (startDate && endDate) {
+        range = timeManager.getCustomRange(startDate, endDate);
+      } else if (timeRange) {
+        range = timeManager.getDateRange(timeRange);
+      } else {
+        return res.status(400).json({ error: 'Must provide either timeRange or startDate and endDate' });
+      }
+
+      if (!range) {
+        return res.status(400).json({ error: 'Invalid time range' });
+      }
+
+      const params = {
+        timeRange,
+        startDate: range.start.toISO(),
+        endDate: range.end.toISO()
+      };
+
+      console.log('[Events Route] Calculating period stats with params:', params);
+      const stats = await eventsService.calculatePeriodStats(params);
+      console.log('[Events Route] Stats response:', {
+        timeRange: {
+          start: range.start.toISO(),
+          end: range.end.toISO()
+        },
+        shippedCount: stats?.shipping?.shippedCount,
+        totalOrders: stats?.orderCount
+      });
+
+      res.json({
+        timeRange: {
+          start: range.start.toISO(),
+          end: range.end.toISO(),
+          displayStart: timeManager.formatForDisplay(range.start),
+          displayEnd: timeManager.formatForDisplay(range.end)
+        },
+        stats
+      });
+    } catch (error) {
+      console.error("[Events Route] Error:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Add new route for smart revenue projection
+  router.get('/projection', async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate } = req.query;
+      console.log('[Events Route] Projection request:', {
+        timeRange,
+        startDate,
+        endDate
+      });
+
+      let range;
+      if (startDate && endDate) {
+        range = timeManager.getCustomRange(startDate, endDate);
+      } else if (timeRange) {
+        range = timeManager.getDateRange(timeRange);
+      } else {
+        return res.status(400).json({ error: 'Must provide either timeRange or startDate and endDate' });
+      }
+
+      if (!range) {
+        return res.status(400).json({ error: 'Invalid time range' });
+      }
+
+      const params = {
+        timeRange,
+        startDate: range.start.toISO(),
+        endDate: range.end.toISO()
+      };
+
+      // Try to get from cache first with a short TTL
+      const cacheKey = redisService._getCacheKey('projection', params);
+      const cachedData = await redisService.get(cacheKey);
+      
+      if (cachedData) {
+        console.log('[Events Route] Cache hit for projection');
+        return res.json(cachedData);
+      }
+
+      console.log('[Events Route] Calculating smart projection with params:', params);
+      const projection = await eventsService.calculateSmartProjection(params);
+      
+      // Cache the results with a short TTL (5 minutes)
+      await redisService.set(cacheKey, projection, 300);
+
+      res.json(projection);
+    } catch (error) {
+      console.error("[Events Route] Error calculating projection:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Add new route for detailed stats
+  router.get('/stats/details', async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate, metric, daily = false } = req.query;
+
+      let range;
+      if (startDate && endDate) {
+        range = timeManager.getCustomRange(startDate, endDate);
+      } else if (timeRange) {
+        range = timeManager.getDateRange(timeRange);
+      } else {
+        return res.status(400).json({ error: 'Must provide either timeRange or startDate and endDate' });
+      }
+
+      if (!range) {
+        return res.status(400).json({ error: 'Invalid time range' });
+      }
+
+      const params = {
+        timeRange,
+        startDate: range.start.toISO(),
+        endDate: range.end.toISO(),
+        metric,
+        daily: daily === 'true' || daily === true
+      };
+
+      // Try to get from cache first
+      const cacheKey = redisService._getCacheKey('stats:details', params);
+      const cachedData = await redisService.get(cacheKey);
+      
+      if (cachedData) {
+        console.log('[Events Route] Cache hit for detailed stats');
+        return res.json({
+          timeRange: {
+            start: range.start.toISO(),
+            end: range.end.toISO(),
+            displayStart: timeManager.formatForDisplay(range.start),
+            displayEnd: timeManager.formatForDisplay(range.end)
+          },
+          stats: cachedData
+        });
+      }
+
+      const stats = await eventsService.calculateDetailedStats(params);
+
+      // Cache the results
+      const ttl = redisService._getTTL(timeRange);
+      await redisService.set(cacheKey, stats, ttl);
+
+      res.json({
+        timeRange: {
+          start: range.start.toISO(),
+          end: range.end.toISO(),
+          displayStart: timeManager.formatForDisplay(range.start),
+          displayEnd: timeManager.formatForDisplay(range.end)
+        },
+        stats
+      });
+    } catch (error) {
+      console.error("[Events Route] Error:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Get product statistics for a time period
+  router.get('/products', async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate } = req.query;
+
+      let range;
+      if (startDate && endDate) {
+        range = timeManager.getCustomRange(startDate, endDate);
+      } else if (timeRange) {
+        range = timeManager.getDateRange(timeRange);
+      } else {
+        return res.status(400).json({ error: 'Must provide either timeRange or startDate and endDate' });
+      }
+
+      if (!range) {
+        return res.status(400).json({ error: 'Invalid time range' });
+      }
+
+      const params = {
+        timeRange,
+        startDate: range.start.toISO(),
+        endDate: range.end.toISO()
+      };
+
+      // Try to get from cache first
+      const cacheKey = redisService._getCacheKey('events', params);
+      const cachedData = await redisService.getEventData('products', params);
+      
+      if (cachedData) {
+        console.log('[Events Route] Cache hit for products');
+        return res.json({
+          timeRange: {
+            start: range.start.toISO(),
+            end: range.end.toISO(),
+            displayStart: timeManager.formatForDisplay(range.start),
+            displayEnd: timeManager.formatForDisplay(range.end)
+          },
+          stats: {
+            products: cachedData
+          }
+        });
+      }
+
+      const stats = await eventsService.calculatePeriodStats(params);
+
+      res.json({
+        timeRange: {
+          start: range.start.toISO(),
+          end: range.end.toISO(),
+          displayStart: timeManager.formatForDisplay(range.start),
+          displayEnd: timeManager.formatForDisplay(range.end)
+        },
+        stats
+      });
+    } catch (error) {
+      console.error("[Events Route] Error:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Get event feed (multiple event types sorted by time)
+  router.get('/feed', async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate, metricIds } = req.query;
+
+      let range;
+      if (startDate && endDate) {
+        range = timeManager.getCustomRange(startDate, endDate);
+      } else if (timeRange) {
+        range = timeManager.getDateRange(timeRange);
+      } else {
+        return res.status(400).json({ error: 'Must provide either timeRange or startDate and endDate' });
+      }
+
+      if (!range) {
+        return res.status(400).json({ error: 'Invalid time range' });
+      }
+
+      const params = {
+        timeRange,
+        startDate: range.start.toISO(),
+        endDate: range.end.toISO(),
+        metricIds: metricIds ? JSON.parse(metricIds) : null
+      };
+
+      const result = await eventsService.getMultiMetricEvents(params);
+
+      res.json({
+        timeRange: {
+          start: range.start.toISO(),
+          end: range.end.toISO(),
+          displayStart: timeManager.formatForDisplay(range.start),
+          displayEnd: timeManager.formatForDisplay(range.end)
+        },
+        ...result
+      });
+    } catch (error) {
+      console.error("[Events Route] Error:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Get aggregated events data
+  router.get('/aggregate', async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate, interval = 'day', metricId, property } = req.query;
+
+      let range;
+      if (startDate && endDate) {
+        range = timeManager.getCustomRange(startDate, endDate);
+      } else if (timeRange) {
+        range = timeManager.getDateRange(timeRange);
+      } else {
+        return res.status(400).json({ error: 'Must provide either timeRange or startDate and endDate' });
+      }
+
+      if (!range) {
+        return res.status(400).json({ error: 'Invalid time range' });
+      }
+
+      const params = {
+        timeRange,
+        startDate: range.start.toISO(),
+        endDate: range.end.toISO(),
+        metricId,
+        interval,
+        property
+      };
+
+      const result = await eventsService.getEvents(params);
+      const groupedData = timeManager.groupEventsByInterval(result.data, interval, property);
+
+      res.json({
+        timeRange: {
+          start: range.start.toISO(),
+          end: range.end.toISO(),
+          displayStart: timeManager.formatForDisplay(range.start),
+          displayEnd: timeManager.formatForDisplay(range.end)
+        },
+        data: groupedData
+      });
+    } catch (error) {
+      console.error("[Events Route] Error:", error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  // Get date range for a given time period
+  router.get("/dateRange", async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate } = req.query;
+
+      let range;
+      if (startDate && endDate) {
+        range = timeManager.getCustomRange(startDate, endDate);
+      } else {
+        range = timeManager.getDateRange(timeRange || 'today');
+      }
+
+      if (!range) {
+        return res.status(400).json({ 
+          error: "Invalid time range parameters" 
+        });
+      }
+
+      res.json({
+        start: range.start.toISO(),
+        end: range.end.toISO(),
+        displayStart: timeManager.formatForDisplay(range.start),
+        displayEnd: timeManager.formatForDisplay(range.end)
+      });
+    } catch (error) {
+      console.error('Error getting date range:', error);
+      res.status(500).json({ 
+        error: "Failed to get date range" 
+      });
+    }
+  });
+
+  // Clear cache for a specific time range
+  router.post("/clearCache", async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate } = req.body;
+      await redisService.clearCache({ timeRange, startDate, endDate });
+      res.json({ message: "Cache cleared successfully" });
+    } catch (error) {
+      console.error('Error clearing cache:', error);
+      res.status(500).json({ error: "Failed to clear cache" });
+    }
+  });
+
+  // Add new batch metrics endpoint
+  router.get('/batch', async (req, res) => {
+    try {
+      const { timeRange, startDate, endDate, metrics } = req.query;
+      
+      // Parse metrics array from query
+      const metricsList = metrics ? JSON.parse(metrics) : [];
+      
+      const params = timeRange === 'custom'
+        ? { startDate, endDate, metrics: metricsList }
+        : { timeRange, metrics: metricsList };
+
+      const results = await eventsService.getBatchMetrics(params);
+      
+      res.json(results);
+    } catch (error) {
+      console.error('[Events Route] Error in batch request:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  return router;
+} 

inventory-server/dashboard/klaviyo-server/routes/index.js

@@ -0,0 +1,17 @@
+import express from 'express';
+import { createEventsRouter } from './events.routes.js';
+import { createMetricsRoutes } from './metrics.routes.js';
+import { createCampaignsRouter } from './campaigns.routes.js';
+import { createReportingRouter } from './reporting.routes.js';
+
+export function createApiRouter(apiKey, apiRevision) {
+  const router = express.Router();
+
+  // Mount routers
+  router.use('/events', createEventsRouter(apiKey, apiRevision));
+  router.use('/metrics', createMetricsRoutes(apiKey, apiRevision));
+  router.use('/campaigns', createCampaignsRouter(apiKey, apiRevision));
+  router.use('/reporting', createReportingRouter(apiKey, apiRevision));
+
+  return router;
+} 

inventory-server/dashboard/klaviyo-server/routes/metrics.routes.js

@@ -0,0 +1,29 @@
+import express from 'express';
+import { MetricsService } from '../services/metrics.service.js';
+
+const router = express.Router();
+
+export function createMetricsRoutes(apiKey, apiRevision) {
+  const metricsService = new MetricsService(apiKey, apiRevision);
+
+  // Get all metrics
+  router.get('/', async (req, res) => {
+    try {
+      console.log('[Metrics Route] Fetching metrics');
+      const data = await metricsService.getMetrics();
+      console.log('[Metrics Route] Success:', {
+        count: data.data?.length || 0
+      });
+      res.json(data);
+    } catch (error) {
+      console.error('[Metrics Route] Error:', error);
+      res.status(500).json({ 
+        status: 'error', 
+        message: error.message,
+        details: error.response?.data || null
+      });
+    }
+  });
+
+  return router;
+} 

inventory-server/dashboard/klaviyo-server/routes/reporting.routes.js

@@ -0,0 +1,29 @@
+import express from 'express';
+import { ReportingService } from '../services/reporting.service.js';
+import { TimeManager } from '../utils/time.utils.js';
+
+export function createReportingRouter(apiKey, apiRevision) {
+  const router = express.Router();
+  const reportingService = new ReportingService(apiKey, apiRevision);
+  const timeManager = new TimeManager();
+
+  // Get campaign reports by time range
+  router.get('/campaigns/:timeRange', async (req, res) => {
+    try {
+      const { timeRange } = req.params;
+      const { channel } = req.query;
+      
+      const reports = await reportingService.getCampaignReports({
+        timeRange,
+        channel
+      });
+
+      res.json(reports);
+    } catch (error) {
+      console.error('[ReportingRoutes] Error fetching campaign reports:', error);
+      res.status(500).json({ error: error.message });
+    }
+  });
+
+  return router;
+} 

inventory-server/dashboard/klaviyo-server/server.js

@@ -0,0 +1,78 @@
+import express from 'express';
+import cors from 'cors';
+import dotenv from 'dotenv';
+import rateLimit from 'express-rate-limit';
+import { createApiRouter } from './routes/index.js';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get directory name in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load environment variables
+const envPath = path.resolve(__dirname, '.env');
+console.log('[Server] Loading .env file from:', envPath);
+dotenv.config({ path: envPath });
+
+// Debug environment variables (without exposing sensitive data)
+console.log('[Server] Environment variables loaded:', {
+  REDIS_HOST: process.env.REDIS_HOST || '(not set)',
+  REDIS_PORT: process.env.REDIS_PORT || '(not set)',
+  REDIS_USERNAME: process.env.REDIS_USERNAME || '(not set)',
+  REDIS_PASSWORD: process.env.REDIS_PASSWORD ? '(set)' : '(not set)',
+  NODE_ENV: process.env.NODE_ENV || '(not set)',
+});
+
+const app = express();
+const port = process.env.KLAVIYO_PORT || 3004;
+
+// Rate limiting for reporting endpoints
+const reportingLimiter = rateLimit({
+  windowMs: 10 * 60 * 1000, // 10 minutes
+  max: 10, // limit each IP to 10 requests per windowMs
+  message: 'Too many requests to reporting endpoint, please try again later',
+  keyGenerator: (req) => {
+    // Use a combination of IP and endpoint for more granular control
+    return `${req.ip}-reporting`;
+  },
+  skip: (req) => {
+    // Only apply to campaign-values-reports endpoint
+    return !req.path.includes('campaign-values-reports');
+  }
+});
+
+// Middleware
+app.use(cors());
+app.use(express.json());
+
+// Debug middleware to log all requests
+app.use((req, res, next) => {
+  console.log(`[${new Date().toISOString()}] ${req.method} ${req.url}`);
+  next();
+});
+
+// Apply rate limiting to reporting endpoints
+app.use('/api/klaviyo/reporting', reportingLimiter);
+
+// Create and mount API routes
+const apiRouter = createApiRouter(
+  process.env.KLAVIYO_API_KEY,
+  process.env.KLAVIYO_API_REVISION || '2024-02-15'
+);
+app.use('/api/klaviyo', apiRouter);
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error('Unhandled error:', err);
+  res.status(500).json({
+    status: 'error',
+    message: 'Internal server error',
+    details: process.env.NODE_ENV === 'development' ? err.message : undefined
+  });
+});
+
+// Start server
+app.listen(port, '0.0.0.0', () => {
+  console.log(`Klaviyo server listening at http://0.0.0.0:${port}`);
+}); 

inventory-server/dashboard/klaviyo-server/services/campaigns.service.js

@@ -0,0 +1,206 @@
+import fetch from 'node-fetch';
+import { TimeManager } from '../utils/time.utils.js';
+import { RedisService } from './redis.service.js';
+
+export class CampaignsService {
+  constructor(apiKey, apiRevision) {
+    this.apiKey = apiKey;
+    this.apiRevision = apiRevision;
+    this.baseUrl = 'https://a.klaviyo.com/api';
+    this.timeManager = new TimeManager();
+    this.redisService = new RedisService();
+  }
+
+  async getCampaigns(params = {}) {
+    try {
+      // Add request debouncing
+      const requestKey = JSON.stringify(params);
+      if (this._pendingRequests && this._pendingRequests[requestKey]) {
+        return this._pendingRequests[requestKey];
+      }
+
+      // Try to get from cache first
+      const cacheKey = this.redisService._getCacheKey('campaigns', params);
+      let cachedData = null;
+      try {
+        cachedData = await this.redisService.get(`${cacheKey}:raw`);
+        if (cachedData) {
+          return cachedData;
+        }
+      } catch (cacheError) {
+        console.warn('[CampaignsService] Cache error:', cacheError);
+      }
+
+      this._pendingRequests = this._pendingRequests || {};
+      this._pendingRequests[requestKey] = (async () => {
+        let allCampaigns = [];
+        let nextCursor = params.pageCursor;
+        let pageCount = 0;
+        
+        const filter = params.filter || this._buildFilter(params);
+        
+        do {
+          const queryParams = new URLSearchParams();
+          if (filter) {
+            queryParams.append('filter', filter);
+          }
+          queryParams.append('sort', params.sort || '-send_time');
+
+          if (nextCursor) {
+            queryParams.append('page[cursor]', nextCursor);
+          }
+
+          const url = `${this.baseUrl}/campaigns?${queryParams.toString()}`;
+
+          try {
+            const response = await fetch(url, {
+              method: 'GET',
+              headers: {
+                'Accept': 'application/json',
+                'Content-Type': 'application/json',
+                'Authorization': `Klaviyo-API-Key ${this.apiKey}`,
+                'revision': this.apiRevision
+              }
+            });
+
+            if (!response.ok) {
+              const errorData = await response.json();
+              console.error('[CampaignsService] API Error:', errorData);
+              throw new Error(`Klaviyo API error: ${response.status} ${response.statusText}`);
+            }
+
+            const responseData = await response.json();
+            allCampaigns = allCampaigns.concat(responseData.data || []);
+            pageCount++;
+            
+            nextCursor = responseData.links?.next ? 
+              new URL(responseData.links.next).searchParams.get('page[cursor]') : null;
+
+            if (nextCursor) {
+              await new Promise(resolve => setTimeout(resolve, 50));
+            }
+          } catch (fetchError) {
+            console.error('[CampaignsService] Fetch error:', fetchError);
+            throw fetchError;
+          }
+          
+        } while (nextCursor);
+
+        const transformedCampaigns = this._transformCampaigns(allCampaigns);
+
+        const result = {
+          data: transformedCampaigns,
+          meta: {
+            total_count: transformedCampaigns.length,
+            page_count: pageCount
+          }
+        };
+
+        try {
+          const ttl = this.redisService._getTTL(params.timeRange);
+          await this.redisService.set(`${cacheKey}:raw`, result, ttl);
+        } catch (cacheError) {
+          console.warn('[CampaignsService] Cache set error:', cacheError);
+        }
+
+        delete this._pendingRequests[requestKey];
+        return result;
+      })();
+
+      return await this._pendingRequests[requestKey];
+    } catch (error) {
+      console.error('[CampaignsService] Error fetching campaigns:', error);
+      throw error;
+    }
+  }
+
+  _buildFilter(params) {
+    const filters = [];
+    
+    if (params.startDate && params.endDate) {
+      const startUtc = this.timeManager.formatForAPI(params.startDate);
+      const endUtc = this.timeManager.formatForAPI(params.endDate);
+      
+      filters.push(`greater-or-equal(send_time,${startUtc})`);
+      filters.push(`less-than(send_time,${endUtc})`);
+    }
+
+    if (params.status) {
+      filters.push(`equals(status,"${params.status}")`);
+    }
+
+    if (params.customFilters) {
+      filters.push(...params.customFilters);
+    }
+
+    return filters.length > 0 ? (filters.length > 1 ? `and(${filters.join(',')})` : filters[0]) : null;
+  }
+
+  async getCampaignsByTimeRange(timeRange, options = {}) {
+    const range = this.timeManager.getDateRange(timeRange);
+    if (!range) {
+      throw new Error('Invalid time range specified');
+    }
+
+    const params = {
+      timeRange,
+      startDate: range.start.toISO(),
+      endDate: range.end.toISO(),
+      ...options
+    };
+
+    // Try to get from cache first
+    const cacheKey = this.redisService._getCacheKey('campaigns', params);
+    let cachedData = null;
+    try {
+      cachedData = await this.redisService.get(`${cacheKey}:raw`);
+      if (cachedData) {
+        return cachedData;
+      }
+    } catch (cacheError) {
+      console.warn('[CampaignsService] Cache error:', cacheError);
+    }
+
+    return this.getCampaigns(params);
+  }
+
+  _transformCampaigns(campaigns) {
+    if (!Array.isArray(campaigns)) {
+      console.warn('[CampaignsService] Campaigns is not an array:', campaigns);
+      return [];
+    }
+
+    return campaigns.map(campaign => {
+      try {
+        const stats = campaign.attributes?.campaign_message?.stats || {};
+        
+        return {
+          id: campaign.id,
+          name: campaign.attributes?.name || "Unnamed Campaign",
+          subject: campaign.attributes?.campaign_message?.subject || "",
+          send_time: campaign.attributes?.send_time,
+          stats: {
+            delivery_rate: stats.delivery_rate || 0,
+            delivered: stats.delivered || 0,
+            recipients: stats.recipients || 0,
+            open_rate: stats.open_rate || 0,
+            opens_unique: stats.opens_unique || 0,
+            opens: stats.opens || 0,
+            clicks_unique: stats.clicks_unique || 0,
+            click_rate: stats.click_rate || 0,
+            click_to_open_rate: stats.click_to_open_rate || 0,
+            conversion_value: stats.conversion_value || 0,
+            conversion_uniques: stats.conversion_uniques || 0
+          }
+        };
+      } catch (error) {
+        console.error('[CampaignsService] Error transforming campaign:', error, campaign);
+        return {
+          id: campaign.id || 'unknown',
+          name: 'Error Processing Campaign',
+          stats: {}
+        };
+      }
+    });
+  }
+} 

inventory-server/dashboard/klaviyo-server/services/metrics.service.js

@@ -0,0 +1,38 @@
+import fetch from 'node-fetch';
+
+export class MetricsService {
+  constructor(apiKey, apiRevision) {
+    this.apiKey = apiKey;
+    this.apiRevision = apiRevision;
+    this.baseUrl = 'https://a.klaviyo.com/api';
+  }
+  async getMetrics() {
+    try {
+      const response = await fetch(`${this.baseUrl}/metrics/`, {
+        headers: {
+          'Authorization': `Klaviyo-API-Key ${this.apiKey}`,
+          'revision': this.apiRevision,
+          'Content-Type': 'application/json',
+          'Accept': 'application/json'
+        }
+      });
+
+      if (!response.ok) {
+        const errorData = await response.json();
+        console.error('[MetricsService] API Error:', errorData);
+        throw new Error(`Klaviyo API error: ${response.status} ${response.statusText}`);
+      }
+
+      const data = await response.json();
+      // Sort the results by name before returning
+      if (data.data) {
+        data.data.sort((a, b) => a.attributes.name.localeCompare(b.attributes.name));
+      }
+
+      return data;
+    } catch (error) {
+      console.error('[MetricsService] Error fetching metrics:', error);
+      throw error;
+    }
+  }
+}

inventory-server/dashboard/klaviyo-server/services/redis.service.js

@@ -0,0 +1,262 @@
+import Redis from 'ioredis';
+import { TimeManager } from '../utils/time.utils.js';
+import dotenv from 'dotenv';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+// Get directory name in ES modules
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+// Load environment variables again (redundant but safe)
+const envPath = path.resolve(__dirname, '../.env');
+console.log('[RedisService] Loading .env file from:', envPath);
+dotenv.config({ path: envPath });
+
+export class RedisService {
+  constructor() {
+    this.timeManager = new TimeManager();
+    this.DEFAULT_TTL = 5 * 60; // 5 minutes default TTL
+    this.isConnected = false;
+    this._initializeRedis();
+  }
+
+  _initializeRedis() {
+    try {
+      // Debug: Print all environment variables we're looking for
+      console.log('[RedisService] Environment variables state:', {
+        REDIS_HOST: process.env.REDIS_HOST ? '(set)' : '(not set)',
+        REDIS_PORT: process.env.REDIS_PORT ? '(set)' : '(not set)',
+        REDIS_USERNAME: process.env.REDIS_USERNAME ? '(set)' : '(not set)',
+        REDIS_PASSWORD: process.env.REDIS_PASSWORD ? '(set)' : '(not set)',
+      });
+
+      // Log Redis configuration (without password)
+      const host = process.env.REDIS_HOST || 'localhost';
+      const port = parseInt(process.env.REDIS_PORT) || 6379;
+      const username = process.env.REDIS_USERNAME || 'default';
+      const password = process.env.REDIS_PASSWORD;
+
+      console.log('[RedisService] Initializing Redis with config:', {
+        host,
+        port,
+        username,
+        hasPassword: !!password
+      });
+
+      const config = {
+        host,
+        port,
+        username,
+        retryStrategy: (times) => {
+          const delay = Math.min(times * 50, 2000);
+          return delay;
+        },
+        maxRetriesPerRequest: 3,
+        enableReadyCheck: true,
+        connectTimeout: 10000,
+        showFriendlyErrorStack: true,
+        retryUnfulfilled: true,
+        maxRetryAttempts: 5
+      };
+
+      // Only add password if it exists
+      if (password) {
+        console.log('[RedisService] Adding password to config');
+        config.password = password;
+      } else {
+        console.warn('[RedisService] No Redis password found in environment variables!');
+      }
+
+      this.client = new Redis(config);
+
+      // Handle connection events
+      this.client.on('connect', () => {
+        console.log('[RedisService] Connected to Redis');
+        this.isConnected = true;
+      });
+
+      this.client.on('ready', () => {
+        console.log('[RedisService] Redis is ready');
+        this.isConnected = true;
+      });
+
+      this.client.on('error', (err) => {
+        console.error('[RedisService] Redis error:', err);
+        this.isConnected = false;
+        // Log more details about the error
+        if (err.code === 'WRONGPASS') {
+          console.error('[RedisService] Authentication failed. Please check your Redis password.');
+        }
+      });
+
+      this.client.on('close', () => {
+        console.log('[RedisService] Redis connection closed');
+        this.isConnected = false;
+      });
+
+      this.client.on('reconnecting', (params) => {
+        console.log('[RedisService] Reconnecting to Redis:', params);
+      });
+
+    } catch (error) {
+      console.error('[RedisService] Error initializing Redis:', error);
+      this.isConnected = false;
+    }
+  }
+
+  async get(key) {
+    if (!this.isConnected) {
+      return null;
+    }
+    
+    try {
+      const data = await this.client.get(key);
+      return data ? JSON.parse(data) : null;
+    } catch (error) {
+      console.error('[RedisService] Error getting data:', error);
+      return null;
+    }
+  }
+
+  async set(key, data, ttl = this.DEFAULT_TTL) {
+    if (!this.isConnected) {
+      return;
+    }
+    
+    try {
+      await this.client.setex(key, ttl, JSON.stringify(data));
+    } catch (error) {
+      console.error('[RedisService] Error setting data:', error);
+    }
+  }
+
+// Helper to generate cache keys
+_getCacheKey(type, params = {}) {
+  const {
+    timeRange,
+    startDate,
+    endDate,
+    metricId,
+    metric,
+    daily,
+    cacheKey,
+    isPreviousPeriod,
+    customFilters
+  } = params;
+
+  let key = `klaviyo:${type}`;
+
+  // Handle "stats:details" for daily or metric-based keys
+  if (type === 'stats:details') {
+    // Add metric to key
+    key += `:${metric || 'all'}`;
+    
+    // Add daily flag if present
+    if (daily) {
+      key += ':daily';
+    }
+    
+    // Add custom filters hash if present
+    if (customFilters?.length) {
+      const filterHash = customFilters.join('').replace(/[^a-zA-Z0-9]/g, '');
+      key += `:${filterHash}`;
+    }
+  }
+
+  // If a specific cache key is provided, use it (highest priority)
+  if (cacheKey) {
+    key += `:${cacheKey}`;
+  } 
+  // Otherwise, build a default cache key
+  else if (timeRange) {
+    key += `:${timeRange}`;
+    if (metricId) {
+      key += `:${metricId}`;
+    }
+    if (isPreviousPeriod) {
+      key += ':prev';
+    }
+  } else if (startDate && endDate) {
+    // For custom date ranges, include both dates in the key
+    key += `:custom:${startDate}:${endDate}`;
+    if (metricId) {
+      key += `:${metricId}`;
+    }
+    if (isPreviousPeriod) {
+      key += ':prev';
+    }
+  }
+
+  // Add order type to key if present
+  if (['pre_orders', 'local_pickup', 'on_hold'].includes(metric)) {
+    key += `:${metric}`;
+  }
+
+  return key;
+}
+
+
+  // Get TTL based on time range
+  _getTTL(timeRange) {
+    const TTL_MAP = {
+      'today': 2 * 60, // 2 minutes
+      'yesterday': 30 * 60, // 30 minutes
+      'thisWeek': 5 * 60, // 5 minutes
+      'lastWeek': 60 * 60, // 1 hour
+      'thisMonth': 10 * 60, // 10 minutes
+      'lastMonth': 2 * 60 * 60, // 2 hours
+      'last7days': 5 * 60, // 5 minutes
+      'last30days': 15 * 60, // 15 minutes
+      'custom': 15 * 60 // 15 minutes
+    };
+    return TTL_MAP[timeRange] || this.DEFAULT_TTL;
+  }
+
+  async getEventData(type, params) {
+    if (!this.isConnected) {
+      return null;
+    }
+    
+    try {
+      const baseKey = this._getCacheKey('events', params);
+      const data = await this.get(`${baseKey}:${type}`);
+      return data;
+    } catch (error) {
+      console.error('[RedisService] Error getting event data:', error);
+      return null;
+    }
+  }
+
+  async cacheEventData(type, params, data) {
+    if (!this.isConnected) {
+      return;
+    }
+    
+    try {
+      const ttl = this._getTTL(params.timeRange);
+      const baseKey = this._getCacheKey('events', params);
+
+      // Cache raw event data
+      await this.set(`${baseKey}:${type}`, data, ttl);
+    } catch (error) {
+      console.error('[RedisService] Error caching event data:', error);
+    }
+  }
+
+  async clearCache(params = {}) {
+    if (!this.isConnected) {
+      return;
+    }
+    
+    try {
+      const pattern = this._getCacheKey('events', params) + '*';
+      const keys = await this.client.keys(pattern);
+      if (keys.length > 0) {
+        await this.client.del(...keys);
+      }
+    } catch (error) {
+      console.error('[RedisService] Error clearing cache:', error);
+    }
+  }
+} 

inventory-server/dashboard/klaviyo-server/services/reporting.service.js

@@ -0,0 +1,254 @@
+import fetch from 'node-fetch';
+import { TimeManager } from '../utils/time.utils.js';
+import { RedisService } from './redis.service.js';
+
+const METRIC_IDS = {
+  PLACED_ORDER: 'Y8cqcF'
+};
+
+export class ReportingService {
+  constructor(apiKey, apiRevision) {
+    this.apiKey = apiKey;
+    this.apiRevision = apiRevision;
+    this.baseUrl = 'https://a.klaviyo.com/api';
+    this.timeManager = new TimeManager();
+    this.redisService = new RedisService();
+    this._pendingReportRequest = null;
+  }
+
+  async getCampaignReports(params = {}) {
+    try {
+      // Check if there's a pending request
+      if (this._pendingReportRequest) {
+        console.log('[ReportingService] Using pending campaign report request');
+        return this._pendingReportRequest;
+      }
+
+      // Try to get from cache first
+      const cacheKey = this.redisService._getCacheKey('campaign_reports', params);
+      let cachedData = null;
+      try {
+        cachedData = await this.redisService.get(`${cacheKey}:raw`);
+        if (cachedData) {
+          console.log('[ReportingService] Using cached campaign report data');
+          return cachedData;
+        }
+      } catch (cacheError) {
+        console.warn('[ReportingService] Cache error:', cacheError);
+      }
+
+      // Create new request promise
+      this._pendingReportRequest = (async () => {
+        console.log('[ReportingService] Fetching fresh campaign report data');
+
+        const range = this.timeManager.getDateRange(params.timeRange || 'last30days');
+        
+        // Determine which channels to fetch based on params
+        const channelsToFetch = params.channel === 'all' || !params.channel
+          ? ['email', 'sms']
+          : [params.channel];
+
+        const allResults = [];
+        
+        // Fetch each channel
+        for (const channel of channelsToFetch) {
+          const payload = {
+            data: {
+              type: "campaign-values-report",
+              attributes: {
+                timeframe: {
+                  start: range.start.toISO(),
+                  end: range.end.toISO()
+                },
+                statistics: [
+                  "delivery_rate",
+                  "delivered",
+                  "recipients",
+                  "open_rate",
+                  "opens_unique",
+                  "opens",
+                  "click_rate",
+                  "clicks_unique",
+                  "click_to_open_rate",
+                  "conversion_value",
+                  "conversion_uniques"
+                ],
+                conversion_metric_id: METRIC_IDS.PLACED_ORDER,
+                filter: `equals(send_channel,"${channel}")`
+              }
+            }
+          };
+
+          const response = await fetch(`${this.baseUrl}/campaign-values-reports`, {
+            method: 'POST',
+            headers: {
+              'Accept': 'application/json',
+              'Content-Type': 'application/json',
+              'Authorization': `Klaviyo-API-Key ${this.apiKey}`,
+              'revision': this.apiRevision
+            },
+            body: JSON.stringify(payload)
+          });
+
+          if (!response.ok) {
+            const errorData = await response.json();
+            console.error('[ReportingService] API Error:', errorData);
+            throw new Error(`Klaviyo API error: ${response.status} ${response.statusText}`);
+          }
+
+          const reportData = await response.json();
+          console.log(`[ReportingService] Raw ${channel} report data:`, JSON.stringify(reportData, null, 2));
+          
+          // Get campaign IDs from the report
+          const campaignIds = reportData.data?.attributes?.results?.map(result => 
+            result.groupings?.campaign_id
+          ).filter(Boolean) || [];
+          
+          if (campaignIds.length > 0) {
+            // Get campaign details including send time and subject lines
+            const campaignDetails = await this.getCampaignDetails(campaignIds);
+            
+            // Process results for this channel
+            const channelResults = reportData.data.attributes.results.map(result => {
+              const campaignId = result.groupings.campaign_id;
+              const details = campaignDetails.find(detail => detail.id === campaignId);
+
+              return {
+                id: campaignId,
+                name: details.attributes.name,
+                subject: details.attributes.subject,
+                send_time: details.attributes.send_time,
+                channel: channel, // Use the channel we're currently processing
+                stats: {
+                  delivery_rate: result.statistics.delivery_rate,
+                  delivered: result.statistics.delivered,
+                  recipients: result.statistics.recipients,
+                  open_rate: result.statistics.open_rate,
+                  opens_unique: result.statistics.opens_unique,
+                  opens: result.statistics.opens,
+                  click_rate: result.statistics.click_rate,
+                  clicks_unique: result.statistics.clicks_unique,
+                  click_to_open_rate: result.statistics.click_to_open_rate,
+                  conversion_value: result.statistics.conversion_value,
+                  conversion_uniques: result.statistics.conversion_uniques
+                }
+              };
+            });
+
+            allResults.push(...channelResults);
+          }
+        }
+
+        // Sort all results by date
+        const enrichedData = {
+          data: allResults.sort((a, b) => {
+            const dateA = new Date(a.send_time);
+            const dateB = new Date(b.send_time);
+            return dateB - dateA; // Sort by date descending
+          })
+        };
+
+        console.log('[ReportingService] Enriched data:', JSON.stringify(enrichedData, null, 2));
+
+        // Cache the enriched response for 10 minutes
+        try {
+          await this.redisService.set(`${cacheKey}:raw`, enrichedData, 600);
+        } catch (cacheError) {
+          console.warn('[ReportingService] Cache set error:', cacheError);
+        }
+
+        return enrichedData;
+      })();
+
+      const result = await this._pendingReportRequest;
+      this._pendingReportRequest = null;
+      return result;
+
+    } catch (error) {
+      console.error('[ReportingService] Error fetching campaign reports:', error);
+      this._pendingReportRequest = null;
+      throw error;
+    }
+  }
+
+  async getCampaignDetails(campaignIds = []) {
+    if (!Array.isArray(campaignIds) || campaignIds.length === 0) {
+      return [];
+    }
+
+    const fetchWithTimeout = async (campaignId, retries = 3) => {
+      for (let i = 0; i < retries; i++) {
+        try {
+          const controller = new AbortController();
+          const timeoutId = setTimeout(() => controller.abort(), 10000); // 10 second timeout
+
+          const response = await fetch(
+            `${this.baseUrl}/campaigns/${campaignId}?include=campaign-messages`,
+            {
+              headers: {
+                'Accept': 'application/json',
+                'Authorization': `Klaviyo-API-Key ${this.apiKey}`,
+                'revision': this.apiRevision
+              },
+              signal: controller.signal
+            }
+          );
+
+          clearTimeout(timeoutId);
+
+          if (!response.ok) {
+            throw new Error(`Failed to fetch campaign ${campaignId}: ${response.status}`);
+          }
+
+          const data = await response.json();
+          if (!data.data) {
+            throw new Error(`Invalid response for campaign ${campaignId}`);
+          }
+
+          const message = data.included?.find(item => item.type === 'campaign-message');
+          
+          console.log('[ReportingService] Campaign details for ID:', campaignId, {
+            send_channel: data.data.attributes.send_channel,
+            raw_attributes: data.data.attributes
+          });
+
+          return {
+            id: data.data.id,
+            type: data.data.type,
+            attributes: {
+              ...data.data.attributes,
+              name: data.data.attributes.name,
+              send_time: data.data.attributes.send_time,
+              subject: message?.attributes?.content?.subject,
+              send_channel: data.data.attributes.send_channel || 'email'
+            }
+          };
+        } catch (error) {
+          if (i === retries - 1) throw error;
+          await new Promise(resolve => setTimeout(resolve, 1000 * (i + 1))); // Exponential backoff
+        }
+      }
+    };
+
+    // Process in smaller chunks to avoid overwhelming the API
+    const chunkSize = 10;
+    const campaignDetails = [];
+    
+    for (let i = 0; i < campaignIds.length; i += chunkSize) {
+      const chunk = campaignIds.slice(i, i + chunkSize);
+      const results = await Promise.all(
+        chunk.map(id => fetchWithTimeout(id).catch(error => {
+          console.error(`Failed to fetch campaign ${id}:`, error);
+          return null;
+        }))
+      );
+      campaignDetails.push(...results.filter(Boolean));
+      
+      if (i + chunkSize < campaignIds.length) {
+        await new Promise(resolve => setTimeout(resolve, 1000)); // 1 second delay between chunks
+      }
+    }
+
+    return campaignDetails;
+  }
+} 

inventory-server/dashboard/klaviyo-server/utils/time.utils.js

@@ -0,0 +1,448 @@
+import { DateTime } from 'luxon';
+
+export class TimeManager {
+  constructor(dayStartHour = 1) {
+    this.timezone = 'America/New_York';
+    this.dayStartHour = dayStartHour; // Hour (0-23) when the business day starts
+    this.weekStartDay = 7; // 7 = Sunday in Luxon
+  }
+
+  /**
+   * Get the start of the current business day
+   * If current time is before dayStartHour, return previous day at dayStartHour
+   */
+  getDayStart(dt = this.getNow()) {
+    if (!dt.isValid) {
+      console.error("[TimeManager] Invalid datetime provided to getDayStart");
+      return this.getNow();
+    }
+    const dayStart = dt.set({ hour: this.dayStartHour, minute: 0, second: 0, millisecond: 0 });
+    return dt.hour < this.dayStartHour ? dayStart.minus({ days: 1 }) : dayStart;
+  }
+
+  /**
+   * Get the end of the current business day
+   * End is defined as dayStartHour - 1 minute on the next day
+   */
+  getDayEnd(dt = this.getNow()) {
+    if (!dt.isValid) {
+      console.error("[TimeManager] Invalid datetime provided to getDayEnd");
+      return this.getNow();
+    }
+    const nextDay = this.getDayStart(dt).plus({ days: 1 });
+    return nextDay.minus({ minutes: 1 });
+  }
+
+  /**
+   * Get the start of the week containing the given date
+   * Aligns with custom day start time and starts on Sunday
+   */
+  getWeekStart(dt = this.getNow()) {
+    if (!dt.isValid) {
+      console.error("[TimeManager] Invalid datetime provided to getWeekStart");
+      return this.getNow();
+    }
+    // Set to start of week (Sunday) and adjust hour
+    const weekStart = dt.set({ weekday: this.weekStartDay }).startOf('day');
+    // If the week start time would be after the given time, go back a week
+    if (weekStart > dt) {
+      return weekStart.minus({ weeks: 1 }).set({ hour: this.dayStartHour });
+    }
+    return weekStart.set({ hour: this.dayStartHour });
+  }
+
+  /**
+   * Convert any date input to a Luxon DateTime in Eastern time
+   */
+  toDateTime(date) {
+    if (!date) return null;
+
+    if (date instanceof DateTime) {
+      return date.setZone(this.timezone);
+    }
+
+    // If it's an ISO string or Date object, parse it
+    const dt = DateTime.fromISO(date instanceof Date ? date.toISOString() : date);
+    if (!dt.isValid) {
+      console.error("[TimeManager] Invalid date input:", date);
+      return null;
+    }
+
+    return dt.setZone(this.timezone);
+  }
+
+  /**
+   * Format a date for API requests (UTC ISO string)
+   */
+  formatForAPI(date) {
+    if (!date) return null;
+
+    // Parse the input date
+    const dt = this.toDateTime(date);
+    if (!dt || !dt.isValid) {
+      console.error("[TimeManager] Invalid date for API:", date);
+      return null;
+    }
+
+    // Convert to UTC for API request
+    const utc = dt.toUTC();
+
+    console.log("[TimeManager] API date conversion:", {
+      input: date,
+      eastern: dt.toISO(),
+      utc: utc.toISO(),
+      offset: dt.offset
+    });
+
+    return utc.toISO();
+  }
+
+  /**
+   * Format a date for display (in Eastern time)
+   */
+  formatForDisplay(date) {
+    const dt = this.toDateTime(date);
+    if (!dt || !dt.isValid) return '';
+    return dt.toFormat('LLL d, yyyy h:mm a');
+  }
+
+  /**
+   * Validate if a date range is valid
+   */
+  isValidDateRange(start, end) {
+    const startDt = this.toDateTime(start);
+    const endDt = this.toDateTime(end);
+    return startDt && endDt && endDt > startDt;
+  }
+
+  /**
+   * Get the current time in Eastern timezone
+   */
+  getNow() {
+    return DateTime.now().setZone(this.timezone);
+  }
+
+  /**
+   * Get a date range for the last N hours
+   */
+  getLastNHours(hours) {
+    const now = this.getNow();
+    return {
+      start: now.minus({ hours }),
+      end: now
+    };
+  }
+
+  /**
+   * Get a date range for the last N days
+   * Aligns with custom day start time
+   */
+  getLastNDays(days) {
+    const now = this.getNow();
+    const dayStart = this.getDayStart(now);
+    return {
+      start: dayStart.minus({ days }),
+      end: this.getDayEnd(now)
+    };
+  }
+
+  /**
+   * Get a date range for a specific time period
+   * All ranges align with custom day start time
+   */
+  getDateRange(period) {
+    const now = this.getNow();
+    
+    // Normalize period to handle both 'last' and 'previous' prefixes
+    const normalizedPeriod = period.startsWith('previous') ? period.replace('previous', 'last') : period;
+    
+    switch (normalizedPeriod) {
+      case 'custom': {
+        // Custom ranges are handled separately via getCustomRange
+        console.warn('[TimeManager] Custom ranges should use getCustomRange method');
+        return null;
+      }
+      case 'today': {
+        const dayStart = this.getDayStart(now);
+        return {
+          start: dayStart,
+          end: this.getDayEnd(now)
+        };
+      }
+      case 'yesterday': {
+        const yesterday = now.minus({ days: 1 });
+        return {
+          start: this.getDayStart(yesterday),
+          end: this.getDayEnd(yesterday)
+        };
+      }
+      case 'last7days': {
+        // For last 7 days, we want to include today and the previous 6 days
+        const dayStart = this.getDayStart(now);
+        const weekStart = dayStart.minus({ days: 6 });
+        return {
+          start: weekStart,
+          end: this.getDayEnd(now)
+        };
+      }
+      case 'last30days': {
+        // Include today and previous 29 days
+        const dayStart = this.getDayStart(now);
+        const monthStart = dayStart.minus({ days: 29 });
+        return {
+          start: monthStart,
+          end: this.getDayEnd(now)
+        };
+      }
+      case 'last90days': {
+        // Include today and previous 89 days
+        const dayStart = this.getDayStart(now);
+        const start = dayStart.minus({ days: 89 });
+        return {
+          start,
+          end: this.getDayEnd(now)
+        };
+      }
+      case 'thisWeek': {
+        // Get the start of the week (Sunday) with custom hour
+        const weekStart = this.getWeekStart(now);
+        return {
+          start: weekStart,
+          end: this.getDayEnd(now)
+        };
+      }
+      case 'lastWeek': {
+        const lastWeek = now.minus({ weeks: 1 });
+        const weekStart = this.getWeekStart(lastWeek);
+        const weekEnd = weekStart.plus({ days: 6 }); // 6 days after start = Saturday
+        return {
+          start: weekStart,
+          end: this.getDayEnd(weekEnd)
+        };
+      }
+      case 'thisMonth': {
+        const dayStart = this.getDayStart(now);
+        const monthStart = dayStart.startOf('month').set({ hour: this.dayStartHour });
+        return {
+          start: monthStart,
+          end: this.getDayEnd(now)
+        };
+      }
+      case 'lastMonth': {
+        const lastMonth = now.minus({ months: 1 });
+        const monthStart = lastMonth.startOf('month').set({ hour: this.dayStartHour });
+        const monthEnd = monthStart.plus({ months: 1 }).minus({ days: 1 });
+        return {
+          start: monthStart,
+          end: this.getDayEnd(monthEnd)
+        };
+      }
+      default:
+        console.warn(`[TimeManager] Unknown period: ${period}`);
+        return null;
+    }
+  }
+
+  /**
+   * Format a duration in milliseconds to a human-readable string
+   */
+  formatDuration(ms) {
+    return DateTime.fromMillis(ms).toFormat("hh'h' mm'm' ss's'");
+  }
+
+  /**
+   * Get relative time string (e.g., "2 hours ago")
+   */
+  getRelativeTime(date) {
+    const dt = this.toDateTime(date);
+    if (!dt) return '';
+    return dt.toRelative();
+  }
+
+  /**
+   * Get a custom date range using exact dates and times provided
+   * @param {string} startDate - ISO string or Date for range start
+   * @param {string} endDate - ISO string or Date for range end
+   * @returns {Object} Object with start and end DateTime objects
+   */
+  getCustomRange(startDate, endDate) {
+    if (!startDate || !endDate) {
+      console.error("[TimeManager] Custom range requires both start and end dates");
+      return null;
+    }
+
+    const start = this.toDateTime(startDate);
+    const end = this.toDateTime(endDate);
+
+    if (!start || !end || !start.isValid || !end.isValid) {
+      console.error("[TimeManager] Invalid dates provided for custom range");
+      return null;
+    }
+
+    // Validate the range
+    if (end < start) {
+      console.error("[TimeManager] End date must be after start date");
+      return null;
+    }
+
+    return {
+      start,
+      end
+    };
+  }
+
+  /**
+   * Get the previous period's date range based on the current period
+   * @param {string} period - The current period
+   * @param {DateTime} now - The current datetime (optional)
+   * @returns {Object} Object with start and end DateTime objects
+   */
+  getPreviousPeriod(period, now = this.getNow()) {
+    const normalizedPeriod = period.startsWith('previous') ? period.replace('previous', 'last') : period;
+    
+    switch (normalizedPeriod) {
+      case 'today': {
+        const yesterday = now.minus({ days: 1 });
+        return {
+          start: this.getDayStart(yesterday),
+          end: this.getDayEnd(yesterday)
+        };
+      }
+      case 'yesterday': {
+        const twoDaysAgo = now.minus({ days: 2 });
+        return {
+          start: this.getDayStart(twoDaysAgo),
+          end: this.getDayEnd(twoDaysAgo)
+        };
+      }
+      case 'last7days': {
+        const dayStart = this.getDayStart(now);
+        const currentStart = dayStart.minus({ days: 6 });
+        const prevEnd = currentStart.minus({ milliseconds: 1 });
+        const prevStart = prevEnd.minus({ days: 6 });
+        return {
+          start: prevStart,
+          end: prevEnd
+        };
+      }
+      case 'last30days': {
+        const dayStart = this.getDayStart(now);
+        const currentStart = dayStart.minus({ days: 29 });
+        const prevEnd = currentStart.minus({ milliseconds: 1 });
+        const prevStart = prevEnd.minus({ days: 29 });
+        return {
+          start: prevStart,
+          end: prevEnd
+        };
+      }
+      case 'last90days': {
+        const dayStart = this.getDayStart(now);
+        const currentStart = dayStart.minus({ days: 89 });
+        const prevEnd = currentStart.minus({ milliseconds: 1 });
+        const prevStart = prevEnd.minus({ days: 89 });
+        return {
+          start: prevStart,
+          end: prevEnd
+        };
+      }
+      case 'thisWeek': {
+        const weekStart = this.getWeekStart(now);
+        const prevEnd = weekStart.minus({ milliseconds: 1 });
+        const prevStart = this.getWeekStart(prevEnd);
+        return {
+          start: prevStart,
+          end: prevEnd
+        };
+      }
+      case 'lastWeek': {
+        const lastWeekStart = this.getWeekStart(now.minus({ weeks: 1 }));
+        const prevEnd = lastWeekStart.minus({ milliseconds: 1 });
+        const prevStart = this.getWeekStart(prevEnd);
+        return {
+          start: prevStart,
+          end: prevEnd
+        };
+      }
+      case 'thisMonth': {
+        const monthStart = now.startOf('month').set({ hour: this.dayStartHour });
+        const prevEnd = monthStart.minus({ milliseconds: 1 });
+        const prevStart = prevEnd.startOf('month').set({ hour: this.dayStartHour });
+        return {
+          start: prevStart,
+          end: prevEnd
+        };
+      }
+      case 'lastMonth': {
+        const lastMonthStart = now.minus({ months: 1 }).startOf('month').set({ hour: this.dayStartHour });
+        const prevEnd = lastMonthStart.minus({ milliseconds: 1 });
+        const prevStart = prevEnd.startOf('month').set({ hour: this.dayStartHour });
+        return {
+          start: prevStart,
+          end: prevEnd
+        };
+      }
+      default:
+        console.warn(`[TimeManager] No previous period defined for: ${period}`);
+        return null;
+    }
+  }
+
+  groupEventsByInterval(events, interval = 'day', property = null) {
+    if (!events?.length) return [];
+
+    const groupedData = new Map();
+    const now = DateTime.now().setZone('America/New_York');
+
+    for (const event of events) {
+      const datetime = DateTime.fromISO(event.attributes.datetime);
+      let groupKey;
+
+      switch (interval) {
+        case 'hour':
+          groupKey = datetime.startOf('hour').toISO();
+          break;
+        case 'day':
+          groupKey = datetime.startOf('day').toISO();
+          break;
+        case 'week':
+          groupKey = datetime.startOf('week').toISO();
+          break;
+        case 'month':
+          groupKey = datetime.startOf('month').toISO();
+          break;
+        default:
+          groupKey = datetime.startOf('day').toISO();
+      }
+
+      const existingGroup = groupedData.get(groupKey) || {
+        datetime: groupKey,
+        count: 0,
+        value: 0
+      };
+
+      existingGroup.count++;
+
+      if (property) {
+        // Extract property value from event
+        const props = event.attributes?.event_properties || event.attributes?.properties || {};
+        let value = 0;
+
+        if (property === '$value') {
+          // Special case for $value - use event value
+          value = Number(event.attributes?.value || 0);
+        } else {
+          // Otherwise get from properties
+          value = Number(props[property] || 0);
+        }
+
+        existingGroup.value = (existingGroup.value || 0) + value;
+      }
+
+      groupedData.set(groupKey, existingGroup);
+    }
+
+    // Convert to array and sort by datetime
+    return Array.from(groupedData.values())
+      .sort((a, b) => DateTime.fromISO(a.datetime) - DateTime.fromISO(b.datetime));
+  }
+} 

inventory-server/dashboard/meta-server/package-lock.json

@@ -0,0 +1,935 @@
+{
+  "name": "meta-server",
+  "version": "1.0.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "meta-server",
+      "version": "1.0.0",
+      "license": "ISC",
+      "dependencies": {
+        "axios": "^1.7.9",
+        "cors": "^2.8.5",
+        "dotenv": "^16.4.7",
+        "express": "^4.21.2"
+      }
+    },
+    "node_modules/accepts": {
+      "version": "1.3.8",
+      "resolved": "https://registry.npmjs.org/accepts/-/accepts-1.3.8.tgz",
+      "integrity": "sha512-PYAthTa2m2VKxuvSD3DPC/Gy+U+sOA1LAuT8mkmRuvw+NACSaeXEQ+NHcVF7rONl6qcaxV3Uuemwawk+7+SJLw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-types": "~2.1.34",
+        "negotiator": "0.6.3"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/array-flatten": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/array-flatten/-/array-flatten-1.1.1.tgz",
+      "integrity": "sha512-PCVAQswWemu6UdxsDFFX/+gVeYqKAod3D3UVm91jHwynguOwAvYPhx8nNlM++NqRcK6CxxpUafjmhIdKiHibqg==",
+      "license": "MIT"
+    },
+    "node_modules/asynckit": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/asynckit/-/asynckit-0.4.0.tgz",
+      "integrity": "sha512-Oei9OH4tRh0YqU3GxhX79dM/mwVgvbZJaSNaRk+bshkj0S5cfHcgYakreBjrHwatXKbz+IoIdYLxrKim2MjW0Q==",
+      "license": "MIT"
+    },
+    "node_modules/axios": {
+      "version": "1.7.9",
+      "resolved": "https://registry.npmjs.org/axios/-/axios-1.7.9.tgz",
+      "integrity": "sha512-LhLcE7Hbiryz8oMDdDptSrWowmB4Bl6RCt6sIJKpRB4XtVf0iEgewX3au/pJqm+Py1kCASkb/FFKjxQaLtxJvw==",
+      "license": "MIT",
+      "dependencies": {
+        "follow-redirects": "^1.15.6",
+        "form-data": "^4.0.0",
+        "proxy-from-env": "^1.1.0"
+      }
+    },
+    "node_modules/body-parser": {
+      "version": "1.20.3",
+      "resolved": "https://registry.npmjs.org/body-parser/-/body-parser-1.20.3.tgz",
+      "integrity": "sha512-7rAxByjUMqQ3/bHJy7D6OGXvx/MMc4IqBn/X0fcM1QUcAItpZrBEYhWGem+tzXH90c+G01ypMcYJBO9Y30203g==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "content-type": "~1.0.5",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "on-finished": "2.4.1",
+        "qs": "6.13.0",
+        "raw-body": "2.5.2",
+        "type-is": "~1.6.18",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/bytes": {
+      "version": "3.1.2",
+      "resolved": "https://registry.npmjs.org/bytes/-/bytes-3.1.2.tgz",
+      "integrity": "sha512-/Nf7TyzTx6S3yRJObOAV7956r8cr2+Oj8AC5dt8wSP3BQAoeX58NoHyCU8P8zGkNXStjTSi6fzO6F0pBdcYbEg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/call-bind-apply-helpers": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/call-bind-apply-helpers/-/call-bind-apply-helpers-1.0.1.tgz",
+      "integrity": "sha512-BhYE+WDaywFg2TBWYNXAE+8B1ATnThNBqXHP5nQu0jWJdVvY2hvkpyB3qOmtmDePiS5/BDQ8wASEWGMWRG148g==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/call-bound": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/call-bound/-/call-bound-1.0.3.tgz",
+      "integrity": "sha512-YTd+6wGlNlPxSuri7Y6X8tY2dmm12UMH66RpKMhiX6rsk5wXXnYgbUcOt8kiS31/AjfoTOvCsE+w8nZQLQnzHA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "get-intrinsic": "^1.2.6"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/combined-stream": {
+      "version": "1.0.8",
+      "resolved": "https://registry.npmjs.org/combined-stream/-/combined-stream-1.0.8.tgz",
+      "integrity": "sha512-FQN4MRfuJeHf7cBbBMJFXhKSDq+2kAArBlmRBvcvFE5BB1HZKXtSFASDhdlz9zOYwxh8lDdnvmMOe/+5cdoEdg==",
+      "license": "MIT",
+      "dependencies": {
+        "delayed-stream": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/content-disposition": {
+      "version": "0.5.4",
+      "resolved": "https://registry.npmjs.org/content-disposition/-/content-disposition-0.5.4.tgz",
+      "integrity": "sha512-FveZTNuGw04cxlAiWbzi6zTAL/lhehaWbTtgluJh4/E95DqMwTmha3KZN1aAWA8cFIhHzMZUvLevkw5Rqk+tSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "safe-buffer": "5.2.1"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/content-type": {
+      "version": "1.0.5",
+      "resolved": "https://registry.npmjs.org/content-type/-/content-type-1.0.5.tgz",
+      "integrity": "sha512-nTjqfcBFEipKdXCv4YDQWCfmcLZKm81ldF0pAopTvyrFGVbcR6P/VAAd5G7N+0tTr8QqiU0tFadD6FK4NtJwOA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie": {
+      "version": "0.7.1",
+      "resolved": "https://registry.npmjs.org/cookie/-/cookie-0.7.1.tgz",
+      "integrity": "sha512-6DnInpx7SJ2AK3+CTUE/ZM0vWTUboZCegxhC2xiIydHR9jNuTAASBrfEpHhiGOZw/nX51bHt6YQl8jsGo4y/0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/cookie-signature": {
+      "version": "1.0.6",
+      "resolved": "https://registry.npmjs.org/cookie-signature/-/cookie-signature-1.0.6.tgz",
+      "integrity": "sha512-QADzlaHc8icV8I7vbaJXJwod9HWYp8uCqf1xa4OfNu1T7JVxQIrUgOWtHdNDtPiywmFbiS12VjotIXLrKM3orQ==",
+      "license": "MIT"
+    },
+    "node_modules/cors": {
+      "version": "2.8.5",
+      "resolved": "https://registry.npmjs.org/cors/-/cors-2.8.5.tgz",
+      "integrity": "sha512-KIHbLJqu73RGr/hnbrO9uBeixNGuvSQjul/jdFvS/KFSIH1hWVd1ng7zOHx+YrEfInLG7q4n6GHQ9cDtxv/P6g==",
+      "license": "MIT",
+      "dependencies": {
+        "object-assign": "^4",
+        "vary": "^1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/debug": {
+      "version": "2.6.9",
+      "resolved": "https://registry.npmjs.org/debug/-/debug-2.6.9.tgz",
+      "integrity": "sha512-bC7ElrdJaJnPbAP+1EotYvqZsb3ecl5wi6Bfi6BJTUcNowp6cvspg0jXznRTKDjm/E7AdgFBVeAPVMNcKGsHMA==",
+      "license": "MIT",
+      "dependencies": {
+        "ms": "2.0.0"
+      }
+    },
+    "node_modules/delayed-stream": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/delayed-stream/-/delayed-stream-1.0.0.tgz",
+      "integrity": "sha512-ZySD7Nf91aLB0RxL4KGrKHBXl7Eds1DAmEdcoVawXnLD7SDhpNgtuII2aAkg7a7QS41jxPSZ17p4VdGnMHk3MQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.4.0"
+      }
+    },
+    "node_modules/depd": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/depd/-/depd-2.0.0.tgz",
+      "integrity": "sha512-g7nH6P6dyDioJogAAGprGpCtVImJhpPk/roCzdb3fIh61/s/nPsfR6onyMwkCAR/OlC3yBC0lESvUoQEAssIrw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/destroy": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/destroy/-/destroy-1.2.0.tgz",
+      "integrity": "sha512-2sJGJTaXIIaR1w4iJSNoN0hnMY7Gpc/n8D4qSCJw8QqFWXf7cuAgnEHxBpweaVcPevC2l3KpjYCx3NypQQgaJg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8",
+        "npm": "1.2.8000 || >= 1.4.16"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.4.7",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz",
+      "integrity": "sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    },
+    "node_modules/dunder-proto": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/dunder-proto/-/dunder-proto-1.0.1.tgz",
+      "integrity": "sha512-KIN/nDJBQRcXw0MLVhZE9iQHmG68qAVIBg9CqmUYjmQIhgij9U5MFvrqkUL5FbtyyzZuOeOt0zdeRe4UY7ct+A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "gopd": "^1.2.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/ee-first": {
+      "version": "1.1.1",
+      "resolved": "https://registry.npmjs.org/ee-first/-/ee-first-1.1.1.tgz",
+      "integrity": "sha512-WMwm9LhRUo+WUaRN+vRuETqG89IgZphVSNkdFgeb6sS/E4OrDIN7t48CAewSHXc6C8lefD8KKfr5vY61brQlow==",
+      "license": "MIT"
+    },
+    "node_modules/encodeurl": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-2.0.0.tgz",
+      "integrity": "sha512-Q0n9HRi4m6JuGIV1eFlmvJB7ZEVxu93IrMyiMsGC0lrMJMWzRgx6WGquyfQgZVb31vhGgXnfmPNNXmxnOkRBrg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/es-define-property": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/es-define-property/-/es-define-property-1.0.1.tgz",
+      "integrity": "sha512-e3nRfgfUZ4rNGL232gUgX06QNyyez04KdjFrF+LTRoOXmrOgFKDg4BCdsjW8EnT69eqdYGmRpJwiPVYNrCaW3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-errors": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/es-errors/-/es-errors-1.3.0.tgz",
+      "integrity": "sha512-Zf5H2Kxt2xjTvbJvP2ZWLEICxA6j+hAmMzIlypy4xcBg1vKVnx89Wy0GbS+kf5cwCVFFzdCFh2XSCFNULS6csw==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/es-object-atoms": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/es-object-atoms/-/es-object-atoms-1.0.0.tgz",
+      "integrity": "sha512-MZ4iQ6JwHOBQjahnjwaC1ZtIBH+2ohjamzAO3oaHcXYup7qxjF2fixyH+Q71voWHeOkI2q/TnJao/KfXYIZWbw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/escape-html": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/escape-html/-/escape-html-1.0.3.tgz",
+      "integrity": "sha512-NiSupZ4OeuGwr68lGIeym/ksIZMJodUGOSCZ/FSnTxcrekbvqrgdUxlJOMpijaKZVjAJrWrGs/6Jy8OMuyj9ow==",
+      "license": "MIT"
+    },
+    "node_modules/etag": {
+      "version": "1.8.1",
+      "resolved": "https://registry.npmjs.org/etag/-/etag-1.8.1.tgz",
+      "integrity": "sha512-aIL5Fx7mawVa300al2BnEE4iNvo1qETxLrPI/o05L7z6go7fCw1J6EQmbK4FmJ2AS7kgVF/KEZWufBfdClMcPg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/express": {
+      "version": "4.21.2",
+      "resolved": "https://registry.npmjs.org/express/-/express-4.21.2.tgz",
+      "integrity": "sha512-28HqgMZAmih1Czt9ny7qr6ek2qddF4FclbMzwhCREB6OFfH+rXAnuNCwo1/wFvrtbgsQDb4kSbX9de9lFbrXnA==",
+      "license": "MIT",
+      "dependencies": {
+        "accepts": "~1.3.8",
+        "array-flatten": "1.1.1",
+        "body-parser": "1.20.3",
+        "content-disposition": "0.5.4",
+        "content-type": "~1.0.4",
+        "cookie": "0.7.1",
+        "cookie-signature": "1.0.6",
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "finalhandler": "1.3.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "merge-descriptors": "1.0.3",
+        "methods": "~1.1.2",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "path-to-regexp": "0.1.12",
+        "proxy-addr": "~2.0.7",
+        "qs": "6.13.0",
+        "range-parser": "~1.2.1",
+        "safe-buffer": "5.2.1",
+        "send": "0.19.0",
+        "serve-static": "1.16.2",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "type-is": "~1.6.18",
+        "utils-merge": "1.0.1",
+        "vary": "~1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.10.0"
+      },
+      "funding": {
+        "type": "opencollective",
+        "url": "https://opencollective.com/express"
+      }
+    },
+    "node_modules/finalhandler": {
+      "version": "1.3.1",
+      "resolved": "https://registry.npmjs.org/finalhandler/-/finalhandler-1.3.1.tgz",
+      "integrity": "sha512-6BN9trH7bp3qvnrRyzsBz+g3lZxTNZTbVO2EV1CS0WIcDbawYVdYvGflME/9QP0h0pYlCDBCTjYa9nZzMDpyxQ==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "on-finished": "2.4.1",
+        "parseurl": "~1.3.3",
+        "statuses": "2.0.1",
+        "unpipe": "~1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/follow-redirects": {
+      "version": "1.15.9",
+      "resolved": "https://registry.npmjs.org/follow-redirects/-/follow-redirects-1.15.9.tgz",
+      "integrity": "sha512-gew4GsXizNgdoRyqmyfMHyAmXsZDk6mHkSxZFCzW9gwlbtOW44CDtYavM+y+72qD/Vq2l550kMF52DT8fOLJqQ==",
+      "funding": [
+        {
+          "type": "individual",
+          "url": "https://github.com/sponsors/RubenVerborgh"
+        }
+      ],
+      "license": "MIT",
+      "engines": {
+        "node": ">=4.0"
+      },
+      "peerDependenciesMeta": {
+        "debug": {
+          "optional": true
+        }
+      }
+    },
+    "node_modules/form-data": {
+      "version": "4.0.1",
+      "resolved": "https://registry.npmjs.org/form-data/-/form-data-4.0.1.tgz",
+      "integrity": "sha512-tzN8e4TX8+kkxGPK8D5u0FNmjPUjw3lwC9lSLxxoB/+GtsJG91CO8bSWy73APlgAZzZbXEYZJuxjkHH2w+Ezhw==",
+      "license": "MIT",
+      "dependencies": {
+        "asynckit": "^0.4.0",
+        "combined-stream": "^1.0.8",
+        "mime-types": "^2.1.12"
+      },
+      "engines": {
+        "node": ">= 6"
+      }
+    },
+    "node_modules/forwarded": {
+      "version": "0.2.0",
+      "resolved": "https://registry.npmjs.org/forwarded/-/forwarded-0.2.0.tgz",
+      "integrity": "sha512-buRG0fpBtRHSTCOASe6hD258tEubFoRLb4ZNA6NxMVHNw2gOcwHo9wyablzMzOA5z9xA9L1KNjk/Nt6MT9aYow==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/fresh": {
+      "version": "0.5.2",
+      "resolved": "https://registry.npmjs.org/fresh/-/fresh-0.5.2.tgz",
+      "integrity": "sha512-zJ2mQYM18rEFOudeV4GShTGIQ7RbzA7ozbU9I/XBpm7kqgMywgmylMwXHxZJmkVoYkna9d2pVXVXPdYTP9ej8Q==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/function-bind": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/function-bind/-/function-bind-1.1.2.tgz",
+      "integrity": "sha512-7XHNxH7qX9xG5mIwxkhumTox/MIRNcOgDrxWsMt2pAr23WHp6MrRlN7FBSFpCpr+oVO0F744iUgR82nJMfG2SA==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/get-intrinsic": {
+      "version": "1.2.6",
+      "resolved": "https://registry.npmjs.org/get-intrinsic/-/get-intrinsic-1.2.6.tgz",
+      "integrity": "sha512-qxsEs+9A+u85HhllWJJFicJfPDhRmjzoYdl64aMWW9yRIJmSyxdn8IEkuIM530/7T+lv0TIHd8L6Q/ra0tEoeA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bind-apply-helpers": "^1.0.1",
+        "dunder-proto": "^1.0.0",
+        "es-define-property": "^1.0.1",
+        "es-errors": "^1.3.0",
+        "es-object-atoms": "^1.0.0",
+        "function-bind": "^1.1.2",
+        "gopd": "^1.2.0",
+        "has-symbols": "^1.1.0",
+        "hasown": "^2.0.2",
+        "math-intrinsics": "^1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/gopd": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/gopd/-/gopd-1.2.0.tgz",
+      "integrity": "sha512-ZUKRh6/kUFoAiTAtTYPZJ3hw9wNxx+BIBOijnlG9PnrJsCcSjs1wyyD6vJpaYtgnzDrKYRSqf3OO6Rfa93xsRg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/has-symbols": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/has-symbols/-/has-symbols-1.1.0.tgz",
+      "integrity": "sha512-1cDNdwJ2Jaohmb3sg4OmKaMBwuC48sYni5HUw2DvsC8LjGTLK9h+eb1X6RyuOHe4hT0ULCW68iomhjUoKUqlPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/hasown": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/hasown/-/hasown-2.0.2.tgz",
+      "integrity": "sha512-0hJU9SCPvmMzIBdZFqNPXWa6dqh7WdH0cII9y+CyS8rG3nL48Bclra9HmKhVVUHyPWNH5Y7xDwAB7bfgSjkUMQ==",
+      "license": "MIT",
+      "dependencies": {
+        "function-bind": "^1.1.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/http-errors": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/http-errors/-/http-errors-2.0.0.tgz",
+      "integrity": "sha512-FtwrG/euBzaEjYeRqOgly7G0qviiXoJWnvEH2Z1plBdXgbyjv34pHTSb9zoeHMyDy33+DWy5Wt9Wo+TURtOYSQ==",
+      "license": "MIT",
+      "dependencies": {
+        "depd": "2.0.0",
+        "inherits": "2.0.4",
+        "setprototypeof": "1.2.0",
+        "statuses": "2.0.1",
+        "toidentifier": "1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/iconv-lite": {
+      "version": "0.4.24",
+      "resolved": "https://registry.npmjs.org/iconv-lite/-/iconv-lite-0.4.24.tgz",
+      "integrity": "sha512-v3MXnZAcvnywkTUEZomIActle7RXXeedOR31wwl7VlyoXO4Qi9arvSenNQWne1TcRwhCL1HwLI21bEqdpj8/rA==",
+      "license": "MIT",
+      "dependencies": {
+        "safer-buffer": ">= 2.1.2 < 3"
+      },
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/inherits": {
+      "version": "2.0.4",
+      "resolved": "https://registry.npmjs.org/inherits/-/inherits-2.0.4.tgz",
+      "integrity": "sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==",
+      "license": "ISC"
+    },
+    "node_modules/ipaddr.js": {
+      "version": "1.9.1",
+      "resolved": "https://registry.npmjs.org/ipaddr.js/-/ipaddr.js-1.9.1.tgz",
+      "integrity": "sha512-0KI/607xoxSToH7GjN1FfSbLoU0+btTicjsQSWQlh/hZykN8KpmMf7uYwPW3R+akZ6R/w18ZlXSHBYXiYUPO3g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/math-intrinsics": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/math-intrinsics/-/math-intrinsics-1.1.0.tgz",
+      "integrity": "sha512-/IXtbwEk5HTPyEwyKX6hGkYXxM9nbj64B+ilVJnC/R6B0pH5G4V3b0pVbL7DBj4tkhBAppbQUlf6F6Xl9LHu1g==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      }
+    },
+    "node_modules/media-typer": {
+      "version": "0.3.0",
+      "resolved": "https://registry.npmjs.org/media-typer/-/media-typer-0.3.0.tgz",
+      "integrity": "sha512-dq+qelQ9akHpcOl/gUVRTxVIOkAJ1wR3QAvb4RsVjS8oVoFjDGTc679wJYmUmknUF5HwMLOgb5O+a3KxfWapPQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/merge-descriptors": {
+      "version": "1.0.3",
+      "resolved": "https://registry.npmjs.org/merge-descriptors/-/merge-descriptors-1.0.3.tgz",
+      "integrity": "sha512-gaNvAS7TZ897/rVaZ0nMtAyxNyi/pdbjbAwUpFQpN70GqnVfOiXpeUUMKRBmzXaSQ8DdTX4/0ms62r2K+hE6mQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/methods": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/methods/-/methods-1.1.2.tgz",
+      "integrity": "sha512-iclAHeNqNm68zFtnZ0e+1L2yUIdvzNoauKU4WBA3VvH/vPFieF7qfRlwUZU+DA9P9bPXIS90ulxoUoCH23sV2w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime": {
+      "version": "1.6.0",
+      "resolved": "https://registry.npmjs.org/mime/-/mime-1.6.0.tgz",
+      "integrity": "sha512-x0Vn8spI+wuJ1O6S7gnbaQg8Pxh4NNHb7KSINmEWKiPE4RKOplvijn+NkmYmmRgP68mc70j2EbeTFRsrswaQeg==",
+      "license": "MIT",
+      "bin": {
+        "mime": "cli.js"
+      },
+      "engines": {
+        "node": ">=4"
+      }
+    },
+    "node_modules/mime-db": {
+      "version": "1.52.0",
+      "resolved": "https://registry.npmjs.org/mime-db/-/mime-db-1.52.0.tgz",
+      "integrity": "sha512-sPU4uV7dYlvtWJxwwxHD0PuihVNiE7TyAbQ5SWxDCB9mUYvOgroQOwYQQOKPJ8CIbE+1ETVlOoK1UC2nU3gYvg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/mime-types": {
+      "version": "2.1.35",
+      "resolved": "https://registry.npmjs.org/mime-types/-/mime-types-2.1.35.tgz",
+      "integrity": "sha512-ZDY+bPm5zTTF+YpCrAU9nK0UgICYPT0QtT1NZWFv4s++TNkcgVaT0g6+4R2uI4MjQjzysHB1zxuWL50hzaeXiw==",
+      "license": "MIT",
+      "dependencies": {
+        "mime-db": "1.52.0"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/ms": {
+      "version": "2.0.0",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.0.0.tgz",
+      "integrity": "sha512-Tpp60P6IUJDTuOq/5Z8cdskzJujfwqfOTkrwIwj7IRISpnkJnT6SyJ4PCPnGMoFjC9ddhal5KVIYtAt97ix05A==",
+      "license": "MIT"
+    },
+    "node_modules/negotiator": {
+      "version": "0.6.3",
+      "resolved": "https://registry.npmjs.org/negotiator/-/negotiator-0.6.3.tgz",
+      "integrity": "sha512-+EUsqGPLsM+j/zdChZjsnX51g4XrHFOIXwfnCVPGlQk/k5giakcKsuxCObBRu6DSm9opw/O6slWbJdghQM4bBg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/object-assign": {
+      "version": "4.1.1",
+      "resolved": "https://registry.npmjs.org/object-assign/-/object-assign-4.1.1.tgz",
+      "integrity": "sha512-rJgTQnkUnH1sFw8yT6VSU3zD3sWmu6sZhIseY8VX+GRu3P6F7Fu+JNDoXfklElbLJSnc3FUQHVe4cU5hj+BcUg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.10.0"
+      }
+    },
+    "node_modules/object-inspect": {
+      "version": "1.13.3",
+      "resolved": "https://registry.npmjs.org/object-inspect/-/object-inspect-1.13.3.tgz",
+      "integrity": "sha512-kDCGIbxkDSXE3euJZZXzc6to7fCrKHNI/hSRQnRuQ+BWjFNzZwiFF8fj/6o2t2G9/jTj8PSIYTfCLelLZEeRpA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/on-finished": {
+      "version": "2.4.1",
+      "resolved": "https://registry.npmjs.org/on-finished/-/on-finished-2.4.1.tgz",
+      "integrity": "sha512-oVlzkg3ENAhCk2zdv7IJwd/QUD4z2RxRwpkcGY8psCVcCYZNq4wYnVWALHM+brtuJjePWiYF/ClmuDr8Ch5+kg==",
+      "license": "MIT",
+      "dependencies": {
+        "ee-first": "1.1.1"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/parseurl": {
+      "version": "1.3.3",
+      "resolved": "https://registry.npmjs.org/parseurl/-/parseurl-1.3.3.tgz",
+      "integrity": "sha512-CiyeOxFT/JZyN5m0z9PfXw4SCBJ6Sygz1Dpl0wqjlhDEGGBP1GnsUVEL0p63hoG1fcj3fHynXi9NYO4nWOL+qQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/path-to-regexp": {
+      "version": "0.1.12",
+      "resolved": "https://registry.npmjs.org/path-to-regexp/-/path-to-regexp-0.1.12.tgz",
+      "integrity": "sha512-RA1GjUVMnvYFxuqovrEqZoxxW5NUZqbwKtYz/Tt7nXerk0LbLblQmrsgdeOxV5SFHf0UDggjS/bSeOZwt1pmEQ==",
+      "license": "MIT"
+    },
+    "node_modules/proxy-addr": {
+      "version": "2.0.7",
+      "resolved": "https://registry.npmjs.org/proxy-addr/-/proxy-addr-2.0.7.tgz",
+      "integrity": "sha512-llQsMLSUDUPT44jdrU/O37qlnifitDP+ZwrmmZcoSKyLKvtZxpyV0n2/bD/N4tBAAZ/gJEdZU7KMraoK1+XYAg==",
+      "license": "MIT",
+      "dependencies": {
+        "forwarded": "0.2.0",
+        "ipaddr.js": "1.9.1"
+      },
+      "engines": {
+        "node": ">= 0.10"
+      }
+    },
+    "node_modules/proxy-from-env": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/proxy-from-env/-/proxy-from-env-1.1.0.tgz",
+      "integrity": "sha512-D+zkORCbA9f1tdWRK0RaCR3GPv50cMxcrz4X8k5LTSUD1Dkw47mKJEZQNunItRTkWwgtaUSo1RVFRIG9ZXiFYg==",
+      "license": "MIT"
+    },
+    "node_modules/qs": {
+      "version": "6.13.0",
+      "resolved": "https://registry.npmjs.org/qs/-/qs-6.13.0.tgz",
+      "integrity": "sha512-+38qI9SOr8tfZ4QmJNplMUxqjbe7LKvvZgWdExBOmd+egZTtjLB67Gu0HRX3u/XOq7UU2Nx6nsjvS16Z9uwfpg==",
+      "license": "BSD-3-Clause",
+      "dependencies": {
+        "side-channel": "^1.0.6"
+      },
+      "engines": {
+        "node": ">=0.6"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/range-parser": {
+      "version": "1.2.1",
+      "resolved": "https://registry.npmjs.org/range-parser/-/range-parser-1.2.1.tgz",
+      "integrity": "sha512-Hrgsx+orqoygnmhFbKaHE6c296J+HTAQXoxEF6gNupROmmGJRoyzfG3ccAveqCBrwr/2yxQ5BVd/GTl5agOwSg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/raw-body": {
+      "version": "2.5.2",
+      "resolved": "https://registry.npmjs.org/raw-body/-/raw-body-2.5.2.tgz",
+      "integrity": "sha512-8zGqypfENjCIqGhgXToC8aB2r7YrBX+AQAfIPs/Mlk+BtPTztOvTS01NRW/3Eh60J+a48lt8qsCzirQ6loCVfA==",
+      "license": "MIT",
+      "dependencies": {
+        "bytes": "3.1.2",
+        "http-errors": "2.0.0",
+        "iconv-lite": "0.4.24",
+        "unpipe": "1.0.0"
+      },
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/safe-buffer": {
+      "version": "5.2.1",
+      "resolved": "https://registry.npmjs.org/safe-buffer/-/safe-buffer-5.2.1.tgz",
+      "integrity": "sha512-rp3So07KcdmmKbGvgaNxQSJr7bGVSVk5S9Eq1F+ppbRo70+YeaDxkw5Dd8NPN+GD6bjnYm2VuPuCXmpuYvmCXQ==",
+      "funding": [
+        {
+          "type": "github",
+          "url": "https://github.com/sponsors/feross"
+        },
+        {
+          "type": "patreon",
+          "url": "https://www.patreon.com/feross"
+        },
+        {
+          "type": "consulting",
+          "url": "https://feross.org/support"
+        }
+      ],
+      "license": "MIT"
+    },
+    "node_modules/safer-buffer": {
+      "version": "2.1.2",
+      "resolved": "https://registry.npmjs.org/safer-buffer/-/safer-buffer-2.1.2.tgz",
+      "integrity": "sha512-YZo3K82SD7Riyi0E1EQPojLz7kpepnSQI9IyPbHHg1XXXevb5dJI7tpyN2ADxGcQbHG7vcyRHk0cbwqcQriUtg==",
+      "license": "MIT"
+    },
+    "node_modules/send": {
+      "version": "0.19.0",
+      "resolved": "https://registry.npmjs.org/send/-/send-0.19.0.tgz",
+      "integrity": "sha512-dW41u5VfLXu8SJh5bwRmyYUbAoSB3c9uQh6L8h/KtsFREPWpbX1lrljJo186Jc4nmci/sGUZ9a0a0J2zgfq2hw==",
+      "license": "MIT",
+      "dependencies": {
+        "debug": "2.6.9",
+        "depd": "2.0.0",
+        "destroy": "1.2.0",
+        "encodeurl": "~1.0.2",
+        "escape-html": "~1.0.3",
+        "etag": "~1.8.1",
+        "fresh": "0.5.2",
+        "http-errors": "2.0.0",
+        "mime": "1.6.0",
+        "ms": "2.1.3",
+        "on-finished": "2.4.1",
+        "range-parser": "~1.2.1",
+        "statuses": "2.0.1"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/send/node_modules/encodeurl": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/encodeurl/-/encodeurl-1.0.2.tgz",
+      "integrity": "sha512-TPJXq8JqFaVYm2CWmPvnP2Iyo4ZSM7/QKcSmuMLDObfpH5fi7RUGmd/rTDf+rut/saiDiQEeVTNgAmJEdAOx0w==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/send/node_modules/ms": {
+      "version": "2.1.3",
+      "resolved": "https://registry.npmjs.org/ms/-/ms-2.1.3.tgz",
+      "integrity": "sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==",
+      "license": "MIT"
+    },
+    "node_modules/serve-static": {
+      "version": "1.16.2",
+      "resolved": "https://registry.npmjs.org/serve-static/-/serve-static-1.16.2.tgz",
+      "integrity": "sha512-VqpjJZKadQB/PEbEwvFdO43Ax5dFBZ2UECszz8bQ7pi7wt//PWe1P6MN7eCnjsatYtBT6EuiClbjSWP2WrIoTw==",
+      "license": "MIT",
+      "dependencies": {
+        "encodeurl": "~2.0.0",
+        "escape-html": "~1.0.3",
+        "parseurl": "~1.3.3",
+        "send": "0.19.0"
+      },
+      "engines": {
+        "node": ">= 0.8.0"
+      }
+    },
+    "node_modules/setprototypeof": {
+      "version": "1.2.0",
+      "resolved": "https://registry.npmjs.org/setprototypeof/-/setprototypeof-1.2.0.tgz",
+      "integrity": "sha512-E5LDX7Wrp85Kil5bhZv46j8jOeboKq5JMmYM3gVGdGH8xFpPWXUMsNrlODCrkoxMEeNi/XZIwuRvY4XNwYMJpw==",
+      "license": "ISC"
+    },
+    "node_modules/side-channel": {
+      "version": "1.1.0",
+      "resolved": "https://registry.npmjs.org/side-channel/-/side-channel-1.1.0.tgz",
+      "integrity": "sha512-ZX99e6tRweoUXqR+VBrslhda51Nh5MTQwou5tnUDgbtyM0dBgmhEDtWGP/xbKn6hqfPRHujUNwz5fy/wbbhnpw==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3",
+        "side-channel-list": "^1.0.0",
+        "side-channel-map": "^1.0.1",
+        "side-channel-weakmap": "^1.0.2"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-list": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/side-channel-list/-/side-channel-list-1.0.0.tgz",
+      "integrity": "sha512-FCLHtRD/gnpCiCHEiJLOwdmFP+wzCmDEkc9y7NsYxeF4u7Btsn1ZuwgwJGxImImHicJArLP4R0yX4c2KCrMrTA==",
+      "license": "MIT",
+      "dependencies": {
+        "es-errors": "^1.3.0",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-map": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/side-channel-map/-/side-channel-map-1.0.1.tgz",
+      "integrity": "sha512-VCjCNfgMsby3tTdo02nbjtM/ewra6jPHmpThenkTYh8pG9ucZ/1P8So4u4FGBek/BjpOVsDCMoLA/iuBKIFXRA==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/side-channel-weakmap": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/side-channel-weakmap/-/side-channel-weakmap-1.0.2.tgz",
+      "integrity": "sha512-WPS/HvHQTYnHisLo9McqBHOJk2FkHO/tlpvldyrnem4aeQp4hai3gythswg6p01oSoTl58rcpiFAjF2br2Ak2A==",
+      "license": "MIT",
+      "dependencies": {
+        "call-bound": "^1.0.2",
+        "es-errors": "^1.3.0",
+        "get-intrinsic": "^1.2.5",
+        "object-inspect": "^1.13.3",
+        "side-channel-map": "^1.0.1"
+      },
+      "engines": {
+        "node": ">= 0.4"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/ljharb"
+      }
+    },
+    "node_modules/statuses": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/statuses/-/statuses-2.0.1.tgz",
+      "integrity": "sha512-RwNA9Z/7PrK06rYLIzFMlaF+l73iwpzsqRIFgbMLbTcLD6cOao82TaWefPXQvB2fOC4AjuYSEndS7N/mTCbkdQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/toidentifier": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/toidentifier/-/toidentifier-1.0.1.tgz",
+      "integrity": "sha512-o5sSPKEkg/DIQNmH43V0/uerLrpzVedkUh8tGNvaeXpfpuwjKenlSox/2O/BTlZUtEe+JG7s5YhEz608PlAHRA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=0.6"
+      }
+    },
+    "node_modules/type-is": {
+      "version": "1.6.18",
+      "resolved": "https://registry.npmjs.org/type-is/-/type-is-1.6.18.tgz",
+      "integrity": "sha512-TkRKr9sUTxEH8MdfuCSP7VizJyzRNMjj2J2do2Jr3Kym598JVdEksuzPQCnlFPW4ky9Q+iA+ma9BGm06XQBy8g==",
+      "license": "MIT",
+      "dependencies": {
+        "media-typer": "0.3.0",
+        "mime-types": "~2.1.24"
+      },
+      "engines": {
+        "node": ">= 0.6"
+      }
+    },
+    "node_modules/unpipe": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/unpipe/-/unpipe-1.0.0.tgz",
+      "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    },
+    "node_modules/utils-merge": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/utils-merge/-/utils-merge-1.0.1.tgz",
+      "integrity": "sha512-pMZTvIkT1d+TFGvDOqodOclx0QWkkgi6Tdoa8gC8ffGAAqz9pzPTZWAybbsHHoED/ztMtkv/VoYTYyShUn81hA==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.4.0"
+      }
+    },
+    "node_modules/vary": {
+      "version": "1.1.2",
+      "resolved": "https://registry.npmjs.org/vary/-/vary-1.1.2.tgz",
+      "integrity": "sha512-BNGbWLfd0eUPabhkXUVm0j8uuvREyTh5ovRa/dyow/BqAbZJyC+5fU+IzQOzmAKzYqYRAISoRhdQr3eIZ/PXqg==",
+      "license": "MIT",
+      "engines": {
+        "node": ">= 0.8"
+      }
+    }
+  }
+}

inventory-server/dashboard/meta-server/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "meta-server",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+        "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "keywords": [],
+  "author": "",
+  "license": "ISC",
+  "description": "",
+  "dependencies": {
+    "axios": "^1.7.9",
+    "cors": "^2.8.5",
+    "dotenv": "^16.4.7",
+    "express": "^4.21.2"
+  }
+}

inventory-server/dashboard/meta-server/routes/campaigns.routes.js

@@ -0,0 +1,91 @@
+const express = require('express');
+const router = express.Router();
+const {
+  fetchCampaigns,
+  fetchAccountInsights,
+  updateCampaignBudget,
+  updateCampaignStatus,
+} = require('../services/meta.service');
+
+// Get all campaigns with insights
+router.get('/campaigns', async (req, res) => {
+  try {
+    const { since, until } = req.query;
+
+    if (!since || !until) {
+      return res.status(400).json({ error: 'Date range is required (since, until)' });
+    }
+
+    const campaigns = await fetchCampaigns(since, until);
+    res.json(campaigns);
+  } catch (error) {
+    console.error('Campaign fetch error:', error);
+    res.status(500).json({
+      error: 'Failed to fetch campaigns',
+      details: error.response?.data?.error?.message || error.message,
+    });
+  }
+});
+
+// Get account insights
+router.get('/account-insights', async (req, res) => {
+  try {
+    const { since, until } = req.query;
+
+    if (!since || !until) {
+      return res.status(400).json({ error: 'Date range is required (since, until)' });
+    }
+
+    const insights = await fetchAccountInsights(since, until);
+    res.json(insights);
+  } catch (error) {
+    console.error('Account insights fetch error:', error);
+    res.status(500).json({
+      error: 'Failed to fetch account insights',
+      details: error.response?.data?.error?.message || error.message,
+    });
+  }
+});
+
+// Update campaign budget
+router.patch('/campaigns/:campaignId/budget', async (req, res) => {
+  try {
+    const { campaignId } = req.params;
+    const { budget } = req.body;
+
+    if (!budget) {
+      return res.status(400).json({ error: 'Budget is required' });
+    }
+
+    const result = await updateCampaignBudget(campaignId, budget);
+    res.json(result);
+  } catch (error) {
+    console.error('Budget update error:', error);
+    res.status(500).json({
+      error: 'Failed to update campaign budget',
+      details: error.response?.data?.error?.message || error.message,
+    });
+  }
+});
+
+// Update campaign status (pause/unpause)
+router.post('/campaigns/:campaignId/:action', async (req, res) => {
+  try {
+    const { campaignId, action } = req.params;
+
+    if (!['pause', 'unpause'].includes(action)) {
+      return res.status(400).json({ error: 'Invalid action. Use "pause" or "unpause"' });
+    }
+
+    const result = await updateCampaignStatus(campaignId, action);
+    res.json(result);
+  } catch (error) {
+    console.error('Status update error:', error);
+    res.status(500).json({
+      error: 'Failed to update campaign status',
+      details: error.response?.data?.error?.message || error.message,
+    });
+  }
+});
+
+module.exports = router;

inventory-server/dashboard/meta-server/server.js

@@ -0,0 +1,31 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+require('dotenv').config({ 
+  path: path.resolve(__dirname, '.env') 
+});
+
+const app = express();
+const port = process.env.PORT || 3005;
+
+app.use(cors());
+app.use(express.json());
+
+// Import routes
+const campaignRoutes = require('./routes/campaigns.routes');
+
+// Use routes
+app.use('/api/meta', campaignRoutes);
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).json({ error: 'Something went wrong!' });
+});
+
+// Start server
+app.listen(port, () => {
+  console.log(`Meta API server running on port ${port}`);
+});
+
+module.exports = app;

inventory-server/dashboard/meta-server/services/meta.service.js

@@ -0,0 +1,99 @@
+const { default: axios } = require('axios');
+
+const META_API_VERSION = process.env.META_API_VERSION || 'v21.0';
+const META_API_BASE_URL = `https://graph.facebook.com/${META_API_VERSION}`;
+const META_ACCESS_TOKEN = process.env.META_ACCESS_TOKEN;
+const AD_ACCOUNT_ID = process.env.META_AD_ACCOUNT_ID;
+
+const metaApiRequest = async (endpoint, params = {}) => {
+  try {
+    const response = await axios.get(`${META_API_BASE_URL}/${endpoint}`, {
+      params: {
+        access_token: META_ACCESS_TOKEN,
+        time_zone: 'America/New_York',
+        ...params,
+      },
+    });
+    return response.data;
+  } catch (error) {
+    console.error('Meta API Error:', {
+      message: error.message,
+      response: error.response?.data,
+      endpoint,
+    });
+    throw error;
+  }
+};
+
+const fetchCampaigns = async (since, until) => {
+  const campaigns = await metaApiRequest(`act_${AD_ACCOUNT_ID}/campaigns`, {
+    fields: [
+      'id',
+      'name',
+      'status',
+      'objective',
+      'daily_budget',
+      'lifetime_budget',
+      'adsets{daily_budget,lifetime_budget}',
+      `insights.time_range({'since':'${since}','until':'${until}'}).level(campaign){
+        spend,
+        impressions,
+        clicks,
+        ctr,
+        reach,
+        frequency,
+        cpm,
+        cpc,
+        actions,
+        action_values,
+        cost_per_action_type
+      }`,
+    ].join(','),
+    limit: 100,
+  });
+
+  return campaigns.data.filter(c => c.insights?.data?.[0]?.spend > 0);
+};
+
+const fetchAccountInsights = async (since, until) => {
+  const accountInsights = await metaApiRequest(`act_${AD_ACCOUNT_ID}/insights`, {
+    fields: 'reach,spend,impressions,clicks,ctr,cpm,actions,action_values',
+    time_range: JSON.stringify({ since, until }),
+  });
+
+  return accountInsights.data[0] || null;
+};
+
+const updateCampaignBudget = async (campaignId, budget) => {
+  try {
+    const response = await axios.post(`${META_API_BASE_URL}/${campaignId}`, {
+      access_token: META_ACCESS_TOKEN,
+      daily_budget: budget * 100, // Convert to cents
+    });
+    return response.data;
+  } catch (error) {
+    console.error('Update campaign budget error:', error);
+    throw error;
+  }
+};
+
+const updateCampaignStatus = async (campaignId, action) => {
+  try {
+    const status = action === 'pause' ? 'PAUSED' : 'ACTIVE';
+    const response = await axios.post(`${META_API_BASE_URL}/${campaignId}`, {
+      access_token: META_ACCESS_TOKEN,
+      status,
+    });
+    return response.data;
+  } catch (error) {
+    console.error('Update campaign status error:', error);
+    throw error;
+  }
+};
+
+module.exports = {
+  fetchCampaigns,
+  fetchAccountInsights,
+  updateCampaignBudget,
+  updateCampaignStatus,
+};

inventory-server/dashboard/package-lock.json

@@ -0,0 +1,24 @@
+{
+  "name": "dashboard",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "dependencies": {
+        "dotenv": "^16.4.7"
+      }
+    },
+    "node_modules/dotenv": {
+      "version": "16.4.7",
+      "resolved": "https://registry.npmjs.org/dotenv/-/dotenv-16.4.7.tgz",
+      "integrity": "sha512-47qPchRCykZC03FhkYAhrvwU4xDBFIj1QPqaarj6mdM/hgUzfPHcpkHJOn3mJAufFeeAxAzeGsr5X0M4k6fLZQ==",
+      "license": "BSD-2-Clause",
+      "engines": {
+        "node": ">=12"
+      },
+      "funding": {
+        "url": "https://dotenvx.com"
+      }
+    }
+  }
+}

inventory-server/dashboard/package.json

@@ -0,0 +1,5 @@
+{
+  "dependencies": {
+    "dotenv": "^16.4.7"
+  }
+}

inventory-server/dashboard/typeform-server/.env.example

@@ -0,0 +1,13 @@
+# Server Configuration
+NODE_ENV=development
+TYPEFORM_PORT=3008
+
+# Redis Configuration
+REDIS_URL=redis://localhost:6379
+
+# Typeform API Configuration
+TYPEFORM_ACCESS_TOKEN=your_typeform_access_token_here
+
+# Optional: Form IDs (if you want to store them in env)
+TYPEFORM_FORM_ID_1=your_first_form_id
+TYPEFORM_FORM_ID_2=your_second_form_id 

inventory-server/dashboard/typeform-server/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "typeform-server",
+  "version": "1.0.0",
+  "description": "Typeform API integration server",
+  "main": "server.js",
+  "scripts": {
+    "start": "node server.js",
+    "dev": "nodemon server.js"
+  },
+  "dependencies": {
+    "axios": "^1.6.2",
+    "cors": "^2.8.5",
+    "dotenv": "^16.3.1",
+    "express": "^4.18.2",
+    "redis": "^4.6.11"
+  },
+  "devDependencies": {
+    "nodemon": "^3.0.2"
+  }
+} 

inventory-server/dashboard/typeform-server/routes/typeform.routes.js

@@ -0,0 +1,121 @@
+const express = require('express');
+const router = express.Router();
+const typeformService = require('../services/typeform.service');
+
+// Get form responses
+router.get('/forms/:formId/responses', async (req, res) => {
+  try {
+    const { formId } = req.params;
+    const filters = req.query;
+    
+    console.log(`Fetching responses for form ${formId} with filters:`, filters);
+    
+    if (!formId) {
+      return res.status(400).json({
+        error: 'Missing form ID',
+        details: 'The form ID parameter is required'
+      });
+    }
+
+    const data = await typeformService.getFormResponsesWithFilters(formId, filters);
+    
+    if (!data) {
+      return res.status(404).json({
+        error: 'No data found',
+        details: `No responses found for form ${formId}`
+      });
+    }
+
+    res.json(data);
+  } catch (error) {
+    console.error('Form responses error:', {
+      formId: req.params.formId,
+      filters: req.query,
+      error: error.message,
+      stack: error.stack,
+      response: error.response?.data
+    });
+    
+    // Handle specific error cases
+    if (error.response?.status === 401) {
+      return res.status(401).json({
+        error: 'Authentication failed',
+        details: 'Invalid Typeform API credentials'
+      });
+    }
+    
+    if (error.response?.status === 404) {
+      return res.status(404).json({
+        error: 'Not found',
+        details: `Form '${req.params.formId}' not found`
+      });
+    }
+
+    if (error.response?.status === 400) {
+      return res.status(400).json({
+        error: 'Invalid request',
+        details: error.response?.data?.message || 'The request was invalid',
+        data: error.response?.data
+      });
+    }
+    
+    res.status(500).json({
+      error: 'Failed to fetch form responses',
+      details: error.response?.data?.message || error.message,
+      data: error.response?.data
+    });
+  }
+});
+
+// Get form insights
+router.get('/forms/:formId/insights', async (req, res) => {
+  try {
+    const { formId } = req.params;
+    
+    if (!formId) {
+      return res.status(400).json({
+        error: 'Missing form ID',
+        details: 'The form ID parameter is required'
+      });
+    }
+
+    const data = await typeformService.getFormInsights(formId);
+    
+    if (!data) {
+      return res.status(404).json({
+        error: 'No data found',
+        details: `No insights found for form ${formId}`
+      });
+    }
+
+    res.json(data);
+  } catch (error) {
+    console.error('Form insights error:', {
+      formId: req.params.formId,
+      error: error.message,
+      response: error.response?.data
+    });
+
+    if (error.response?.status === 401) {
+      return res.status(401).json({
+        error: 'Authentication failed',
+        details: 'Invalid Typeform API credentials'
+      });
+    }
+
+    if (error.response?.status === 404) {
+      return res.status(404).json({
+        error: 'Not found',
+        details: `Form '${req.params.formId}' not found`
+      });
+    }
+
+    res.status(500).json({
+      error: 'Failed to fetch form insights',
+      details: error.response?.data?.message || error.message,
+      data: error.response?.data
+    });
+  }
+});
+
+module.exports = router; 

inventory-server/dashboard/typeform-server/server.js

@@ -0,0 +1,31 @@
+const express = require('express');
+const cors = require('cors');
+const path = require('path');
+require('dotenv').config({ 
+  path: path.resolve(__dirname, '.env') 
+});
+
+const app = express();
+const port = process.env.TYPEFORM_PORT || 3008;
+
+app.use(cors());
+app.use(express.json());
+
+// Import routes
+const typeformRoutes = require('./routes/typeform.routes');
+
+// Use routes
+app.use('/api/typeform', typeformRoutes);
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).json({ error: 'Something went wrong!' });
+});
+
+// Start server
+app.listen(port, () => {
+  console.log(`Typeform API server running on port ${port}`);
+});
+
+module.exports = app; 

inventory-server/dashboard/typeform-server/services/typeform.service.js

@@ -0,0 +1,142 @@
+const axios = require('axios');
+const { createClient } = require('redis');
+
+class TypeformService {
+  constructor() {
+    this.redis = createClient({
+      url: process.env.REDIS_URL
+    });
+    
+    this.redis.on('error', err => console.error('Redis Client Error:', err));
+    this.redis.connect().catch(err => console.error('Redis connection error:', err));
+    
+    const token = process.env.TYPEFORM_ACCESS_TOKEN;
+    console.log('Initializing Typeform client with token:', token ? `${token.slice(0, 10)}...` : 'missing');
+    
+    this.apiClient = axios.create({
+      baseURL: 'https://api.typeform.com',
+      headers: {
+        'Authorization': `Bearer ${token}`,
+        'Content-Type': 'application/json'
+      }
+    });
+
+    // Test the token
+    this.testConnection();
+  }
+
+  async testConnection() {
+    try {
+      const response = await this.apiClient.get('/forms');
+      console.log('Typeform connection test successful:', {
+        status: response.status,
+        headers: response.headers,
+      });
+    } catch (error) {
+      console.error('Typeform connection test failed:', {
+        error: error.message,
+        response: error.response?.data,
+        status: error.response?.status,
+      });
+    }
+  }
+
+  async getFormResponses(formId, params = {}) {
+    const cacheKey = `typeform:responses:${formId}:${JSON.stringify(params)}`;
+    
+    try {
+      // Try Redis first
+      const cachedData = await this.redis.get(cacheKey);
+      if (cachedData) {
+        console.log(`Form responses for ${formId} found in Redis cache`);
+        return JSON.parse(cachedData);
+      }
+
+      // Fetch from API
+      const response = await this.apiClient.get(`/forms/${formId}/responses`, { params });
+      const data = response.data;
+
+      // Save to Redis with 5 minute expiry
+      await this.redis.set(cacheKey, JSON.stringify(data), {
+        EX: 300 // 5 minutes
+      });
+
+      return data;
+    } catch (error) {
+      console.error(`Error fetching form responses for ${formId}:`, {
+        error: error.message,
+        params,
+        response: error.response?.data
+      });
+      throw error;
+    }
+  }
+
+  async getFormInsights(formId) {
+    const cacheKey = `typeform:insights:${formId}`;
+    
+    try {
+      // Try Redis first
+      const cachedData = await this.redis.get(cacheKey);
+      if (cachedData) {
+        console.log(`Form insights for ${formId} found in Redis cache`);
+        return JSON.parse(cachedData);
+      }
+
+      // Log the request details
+      console.log(`Fetching insights for form ${formId}...`, {
+        url: `/insights/${formId}/summary`,
+        headers: this.apiClient.defaults.headers
+      });
+
+      // Fetch from API
+      const response = await this.apiClient.get(`/insights/${formId}/summary`);
+      console.log('Typeform insights response:', {
+        status: response.status,
+        headers: response.headers,
+        data: response.data
+      });
+      const data = response.data;
+
+      // Save to Redis with 5 minute expiry
+      await this.redis.set(cacheKey, JSON.stringify(data), {
+        EX: 300 // 5 minutes
+      });
+
+      return data;
+    } catch (error) {
+      console.error(`Error fetching form insights for ${formId}:`, {
+        error: error.message,
+        response: error.response?.data,
+        status: error.response?.status,
+        headers: error.response?.headers,
+        requestUrl: `/insights/${formId}/summary`,
+        requestHeaders: this.apiClient.defaults.headers
+      });
+      throw error;
+    }
+  }
+
+  async getFormResponsesWithFilters(formId, { since, until, pageSize = 25, ...otherParams } = {}) {
+    try {
+      const params = {
+        page_size: pageSize,
+        ...otherParams
+      };
+
+      if (since) {
+        params.since = new Date(since).toISOString();
+      }
+      if (until) {
+        params.until = new Date(until).toISOString();
+      }
+
+      return await this.getFormResponses(formId, params);
+    } catch (error) {
+      console.error('Error in getFormResponsesWithFilters:', error);
+      throw error;
+    }
+  }
+}
+
+module.exports = new TypeformService(); 

inventory/src/components/product-import/steps/ValidationStepNew/components/ValidationCell.tsx

@@ -11,7 +11,6 @@ import InputCell from './cells/InputCell'
 import SelectCell from './cells/SelectCell'
 import MultiSelectCell from './cells/MultiSelectCell'
 import { TableCell } from '@/components/ui/table'
-import { Skeleton } from '@/components/ui/skeleton'
 
 // Context for copy down selection mode
 export const CopyDownContext = React.createContext<{
@@ -80,7 +79,8 @@ const BaseCellContent = React.memo(({
   className = '',
   fieldKey = '',
   onStartEdit,
-  onEndEdit
+  onEndEdit,
+  isValidating
 }: {
   field: Field<string>;
   value: any;
@@ -91,6 +91,7 @@ const BaseCellContent = React.memo(({
   fieldKey?: string;
   onStartEdit?: () => void;
   onEndEdit?: () => void;
+  isValidating?: boolean;
 }) => {
   // Get field type information
   const fieldType = fieldKey === 'line' || fieldKey === 'subline' 
@@ -123,6 +124,7 @@ const BaseCellContent = React.memo(({
         hasErrors={hasErrors}
         className={className}
         disabled={field.disabled}
+        isValidating={isValidating}
       />
     );
   }
@@ -139,6 +141,7 @@ const BaseCellContent = React.memo(({
         hasErrors={hasErrors}
         className={className}
         disabled={field.disabled}
+        isValidating={isValidating}
       />
     );
   }
@@ -155,6 +158,7 @@ const BaseCellContent = React.memo(({
         hasErrors={hasErrors}
         className={className}
         disabled={field.disabled}
+        isValidating={isValidating}
       />
     );
   }
@@ -170,6 +174,7 @@ const BaseCellContent = React.memo(({
       isMultiline={isMultiline}
       isPrice={isPrice}
       disabled={field.disabled}
+      isValidating={isValidating}
     />
   );
 }, (prev, next) => {
@@ -466,35 +471,33 @@ const ValidationCell = React.memo(({
             </TooltipProvider>
           </div>
         )}
-        {isLoading ? (
-          <div className={`flex items-center justify-center gap-2 border ${hasError || isRequiredButEmpty ? 'border-red-500' : 'border-input'} rounded-md px-2 py-2`}>
-            <Skeleton className="w-full h-4" />
-          </div>
-        ) : (
-          <div 
-            className={`truncate overflow-hidden ${isCopyDownHovered && !copyDownContext.isInCopyDownMode ? 'bg-blue-50/50' : ''}`}
-            style={{
-              backgroundColor: isSourceCell ? '#dbeafe' : 
-                              isSelectedTarget ? '#bfdbfe' : 
-                              isInTargetRow && isTargetRowHovered ? '#dbeafe' : 
-                              undefined,
-              borderRadius: (isSourceCell || isSelectedTarget || isInTargetRow) ? '0.375rem' : undefined,
-              boxShadow: isSourceCell ? '0 0 0 2px #3b82f6' : undefined
-            }}
-          >
-            <BaseCellContent
-              field={field}
-              value={displayValue}
-              onChange={onChange}
-              hasErrors={hasError || isRequiredButEmpty}
-              options={options}
-              className={cellClassName}
-              fieldKey={fieldKey}
-              onStartEdit={handleStartEdit}
-              onEndEdit={handleEndEdit}
-            />
-          </div>
-        )}
+        <div 
+          className={`relative truncate overflow-hidden ${isCopyDownHovered && !copyDownContext.isInCopyDownMode ? 'bg-blue-50/50' : ''}`}
+          style={{
+            backgroundColor: isSourceCell ? '#dbeafe' : 
+                            isSelectedTarget ? '#bfdbfe' : 
+                            isInTargetRow && isTargetRowHovered ? '#dbeafe' : 
+                            undefined,
+            borderRadius: (isSourceCell || isSelectedTarget || isInTargetRow) ? '0.375rem' : undefined,
+            boxShadow: isSourceCell ? '0 0 0 2px #3b82f6' : undefined
+          }}
+        >
+          <BaseCellContent
+            field={field}
+            value={displayValue}
+            onChange={onChange}
+            hasErrors={hasError || isRequiredButEmpty}
+            options={options}
+            className={cellClassName}
+            fieldKey={fieldKey}
+            onStartEdit={handleStartEdit}
+            onEndEdit={handleEndEdit}
+            isValidating={isLoading}
+          />
+          {isLoading && (
+            <span className="pointer-events-none absolute right-2 top-2 h-2 w-2 rounded-full bg-muted-foreground animate-pulse" />
+          )}
+        </div>
       </div>
     </TableCell>
   );

inventory/src/components/product-import/steps/ValidationStepNew/components/ValidationTable.tsx

@@ -1,4 +1,4 @@
-import React, { useMemo, useCallback, useState } from 'react'
+import React, { useMemo, useCallback, useState, useEffect, useRef } from 'react'
 import { 
   useReactTable, 
   getCoreRowModel, 
@@ -6,6 +6,7 @@ import {
   RowSelectionState,
   ColumnDef
 } from '@tanstack/react-table'
+import { useVirtualizer } from '@tanstack/react-virtual'
 import { Fields, Field } from '../../../types'
 import { RowData, Template } from '../hooks/validationTypes'
 import ValidationCell, { CopyDownContext } from './ValidationCell'
@@ -193,6 +194,14 @@ const ValidationTable = <T extends string>({
   upcValidationResults
 }: ValidationTableProps<T>) => {
   const { translations } = useRsi<T>();
+  const tableRootRef = useRef<HTMLDivElement | null>(null);
+  const getScrollElement = useCallback(() => tableRootRef.current?.parentElement ?? null, []);
+  const [, forceRerender] = useState(0);
+
+  useEffect(() => {
+    if (!tableRootRef.current) return;
+    forceRerender((value) => value + 1);
+  }, []);
 
   // Add state for copy down selection mode
   const [isInCopyDownMode, setIsInCopyDownMode] = useState(false);
@@ -392,7 +401,10 @@ const ValidationTable = <T extends string>({
         } else if (fieldKey === 'subline' && rowId && rowSublines[rowId]) {
           options = rowSublines[rowId];
         }
-        
+
+        const validatingKey = `${row.index}-${fieldKey}`;
+        const isCellValidating = validatingCells.has(validatingKey);
+
         // Get the current cell value first
         const currentValue = fieldKey === 'item_number' && row.original[field.key] 
                            ? row.original[field.key] 
@@ -471,7 +483,7 @@ const ValidationTable = <T extends string>({
             value={currentValue}
             onChange={(value) => handleFieldUpdate(row.index, field.key as T, value)}
             errors={cellErrors}
-            isValidating={isLoading}
+            isValidating={isLoading || isCellValidating}
             fieldKey={fieldKey}
             options={options}
             itemNumber={itemNumber}
@@ -505,6 +517,47 @@ const ValidationTable = <T extends string>({
     getRowId: useCallback((_row: RowData<T>, index: number) => String(index), []),
   });
 
+  const rowModel = table.getRowModel();
+  const rows = rowModel.rows;
+  const visibleColumnCount = table.getVisibleFlatColumns().length;
+
+  const rowVirtualizer = useVirtualizer({
+    count: rows.length,
+    getScrollElement,
+    estimateSize: () => 66,
+    overscan: 8,
+    measureElement:
+      typeof window !== 'undefined'
+        ? (el: Element | null) => el?.getBoundingClientRect().height || 0
+        : undefined,
+  });
+
+  const scrollElement = getScrollElement();
+
+  const virtualRows = scrollElement
+    ? rowVirtualizer.getVirtualItems()
+    : rows.map((_, index) => ({
+        index,
+        key: `row-fallback-${index}`,
+        start: 0,
+        end: 0,
+        size: 0,
+      }));
+  const paddingTop = scrollElement && virtualRows.length > 0 ? virtualRows[0].start : 0;
+  const paddingBottom =
+    scrollElement && virtualRows.length > 0
+      ? rowVirtualizer.getTotalSize() - virtualRows[virtualRows.length - 1].end
+      : 0;
+
+  const measureVirtualRow = useCallback(
+    (node: HTMLTableRowElement | null) => {
+      const scrollEl = getScrollElement();
+      if (!scrollEl || !node) return;
+      rowVirtualizer.measureElement(node);
+    },
+    [getScrollElement, rowVirtualizer]
+  );
+
   // Calculate total table width for stable horizontal scrolling
   const totalWidth = useMemo(() => {
     return columns.reduce((total, col) => total + (col.size || 0), 0);
@@ -525,7 +578,7 @@ const ValidationTable = <T extends string>({
 
   return (
     <CopyDownContext.Provider value={copyDownContextValue}>
-      <div className="min-w-max relative">
+      <div ref={tableRootRef} className="min-w-max relative">
         {/* Add global styles for copy down mode */}
         {isInCopyDownMode && (
           <style>
@@ -630,7 +683,17 @@ const ValidationTable = <T extends string>({
             transform: 'translateZ(0)' // Force GPU acceleration
           }}>
             <TableBody>
-              {table.getRowModel().rows.map((row) => {
+              {paddingTop > 0 && (
+                <TableRow key="virtual-padding-top">
+                  <TableCell
+                    colSpan={visibleColumnCount}
+                    style={{ height: `${paddingTop}px`, padding: 0, border: 'none' }}
+                  />
+                </TableRow>
+              )}
+              {virtualRows.map((virtualRow) => {
+                const row = rows[virtualRow.index];
+                if (!row) return null;
                 // Precompute validation error status for this row
                 const hasErrors = validationErrors.has(parseInt(row.id)) && 
                                 Object.keys(validationErrors.get(parseInt(row.id)) || {}).length > 0;
@@ -659,6 +722,7 @@ const ValidationTable = <T extends string>({
                       isCopyDownTarget ? "cursor-pointer copy-down-target-row" : ""
                     )}
                     style={rowStyle}
+                    ref={scrollElement ? measureVirtualRow : undefined}
                     onMouseEnter={() => handleRowMouseEnter(parseInt(row.id))}
                   >
                     {row.getVisibleCells().map((cell: any) => (
@@ -669,6 +733,14 @@ const ValidationTable = <T extends string>({
                   </TableRow>
                 );
               })}
+              {paddingBottom > 0 && (
+                <TableRow key="virtual-padding-bottom">
+                  <TableCell
+                    colSpan={visibleColumnCount}
+                    style={{ height: `${paddingBottom}px`, padding: 0, border: 'none' }}
+                  />
+                </TableRow>
+              )}
             </TableBody>
           </Table>
         </div>

inventory/src/components/product-import/steps/ValidationStepNew/components/cells/InputCell.tsx

@@ -1,4 +1,4 @@
-import React, { useState, useCallback, useMemo } from 'react'
+import React, { useState, useCallback, useMemo, useEffect } from 'react'
 import { Field } from '../../../../types'
 import { Input } from '@/components/ui/input'
 import { cn } from '@/lib/utils'
@@ -15,8 +15,10 @@ interface InputCellProps<T extends string> {
   isPrice?: boolean
   disabled?: boolean
   className?: string
+  isValidating?: boolean
 }
 
+
 // (removed unused formatPrice helper)
 
 const InputCell = <T extends string>({
@@ -29,11 +31,12 @@ const InputCell = <T extends string>({
   isMultiline = false,
   isPrice = false,
   disabled = false,
-  className = ''
+  className = '', isValidating: _isValidating = false
 }: InputCellProps<T>) => {
   const [isEditing, setIsEditing] = useState(false);
   const [editValue, setEditValue] = useState('');
   const [isHovered, setIsHovered] = useState(false);
+  const [pendingDisplayValue, setPendingDisplayValue] = useState<string | null>(null);
   
   // Remove optimistic updates and rely on parent state
   
@@ -48,6 +51,7 @@ const InputCell = <T extends string>({
   // Handle focus event
   const handleFocus = useCallback(() => {
     setIsEditing(true);
+    setPendingDisplayValue(null);
     
     if (value !== undefined && value !== null) {
       if (isPrice) {
@@ -67,6 +71,8 @@ const InputCell = <T extends string>({
   // Handle blur event - save to parent only
   const handleBlur = useCallback(() => {
     const finalValue = editValue.trim();
+
+    setPendingDisplayValue(finalValue);
     
     // Save to parent - parent must update immediately for this to work
     onChange(finalValue);
@@ -81,23 +87,29 @@ const InputCell = <T extends string>({
     const newValue = isPrice ? e.target.value.replace(/[$,]/g, '') : e.target.value;
     setEditValue(newValue);
   }, [isPrice]);
-  
-  // Get the display value - use parent value directly
-  const displayValue = useMemo(() => {
+
+  useEffect(() => {
+    if (pendingDisplayValue === null) return;
     const currentValue = value ?? '';
-    
-    // Handle price formatting for display
-    if (isPrice && currentValue !== '' && currentValue !== undefined && currentValue !== null) {
-      if (typeof currentValue === 'number') {
-        return currentValue.toFixed(2);
-      } else if (typeof currentValue === 'string' && /^-?\d+(\.\d+)?$/.test(currentValue)) {
-        return parseFloat(currentValue).toFixed(2);
+    if (String(currentValue) === pendingDisplayValue) {
+      setPendingDisplayValue(null);
+    }
+  }, [value, pendingDisplayValue]);
+  
+  // Get the display value - prefer pending value when present for immediate feedback
+  const displayValue = useMemo(() => {
+    const rawValue = pendingDisplayValue !== null ? pendingDisplayValue : value ?? '';
+
+    if (isPrice && rawValue !== '' && rawValue !== undefined && rawValue !== null) {
+      if (typeof rawValue === 'number') {
+        return rawValue.toFixed(2);
+      } else if (typeof rawValue === 'string' && /^-?\d+(\.\d+)?$/.test(rawValue)) {
+        return parseFloat(rawValue).toFixed(2);
       }
     }
-    
-    // For non-price or invalid price values, return as-is
-    return String(currentValue);
-  }, [isPrice, value]);
+
+    return String(rawValue);
+  }, [isPrice, value, pendingDisplayValue]);
   
   // Add outline even when not in focus
   const outlineClass = "border focus-visible:ring-0 focus-visible:ring-offset-0";

inventory/src/components/product-import/steps/ValidationStepNew/components/cells/MultiSelectCell.tsx

@@ -24,8 +24,10 @@ interface MultiSelectCellProps<T extends string> {
   options?: readonly FieldOption[]
   disabled?: boolean
   className?: string
+  isValidating?: boolean
 }
 
+
 // Memoized option item to prevent unnecessary renders for large option lists
 const OptionItem = React.memo(({
   option,
@@ -158,7 +160,7 @@ const MultiSelectCell = <T extends string>({
   hasErrors,
   options: providedOptions,
   disabled = false,
-  className = ''
+  className = '', isValidating: _isValidating = false
 }: MultiSelectCellProps<T>) => {
   const [open, setOpen] = useState(false)
   const [searchQuery, setSearchQuery] = useState("")

inventory/src/components/product-import/steps/ValidationStepNew/components/cells/SelectCell.tsx

@@ -22,8 +22,10 @@ interface SelectCellProps<T extends string> {
   options: readonly any[]
   disabled?: boolean
   className?: string
+  isValidating?: boolean
 }
 
+
 // Lightweight version of the select cell with minimal dependencies
 const SelectCell = <T extends string>({
   field,
@@ -34,7 +36,7 @@ const SelectCell = <T extends string>({
   hasErrors,
   options = [],
   disabled = false,
-  className = ''
+  className = '', isValidating = false
 }: SelectCellProps<T>) => {
   // State for the open/closed state of the dropdown
   const [open, setOpen] = useState(false);
@@ -47,6 +49,7 @@ const SelectCell = <T extends string>({
   
   // State to track if the value is being processed/validated
   const [isProcessing, setIsProcessing] = useState(false);
+  const showProcessing = isProcessing || isValidating;
   
   // Add state for hover
   const [isHovered, setIsHovered] = useState(false);
@@ -61,8 +64,10 @@ const SelectCell = <T extends string>({
   useEffect(() => {
     setInternalValue(value);
     // When the value prop changes, it means validation is complete
-    setIsProcessing(false);
-  }, [value]);
+    if (!isValidating) {
+      setIsProcessing(false);
+    }
+  }, [value, isValidating]);
   
   // Memoize options processing to avoid recalculation on every render
   const selectOptions = useMemo(() => {
@@ -144,7 +149,9 @@ const SelectCell = <T extends string>({
     
     // 6. Clear processing state after a short delay - reduced for responsiveness
     setTimeout(() => {
+      if (!isValidating) {
       setIsProcessing(false);
+    }
     }, 50);
   }, [onChange, onEndEdit]);
 
@@ -200,7 +207,7 @@ const SelectCell = <T extends string>({
             "w-full justify-between font-normal",
             "border",
             !internalValue && "text-muted-foreground",
-            isProcessing && "text-muted-foreground",
+            showProcessing && "text-muted-foreground",
             hasErrors ? "border-destructive" : "",
             className
           )}
@@ -233,7 +240,7 @@ const SelectCell = <T extends string>({
           onMouseEnter={() => setIsHovered(true)}
           onMouseLeave={() => setIsHovered(false)}
         >
-          <span className={isProcessing ? "opacity-70" : ""}>
+          <span className={showProcessing ? "opacity-70" : ""}>
             {displayValue}
           </span>
           <ChevronsUpDown className="mr-1.5 h-4 w-4 shrink-0 opacity-50" />

inventory/src/components/product-import/steps/ValidationStepNew/hooks/useRowOperations.tsx

@@ -1,21 +1,100 @@
-import { useCallback, useMemo } from 'react';
-import { RowData } from './validationTypes';
+import { useCallback, useEffect, useMemo, useRef, startTransition } from 'react';
+import type { Dispatch, SetStateAction } from 'react';
+import { RowData, isEmpty as isValueEmpty } from './validationTypes';
 import type { Field, Fields } from '../../../types';
 import { ErrorSources, ErrorType, ValidationError } from '../../../types';
 import { useUniqueValidation } from './useUniqueValidation';
-import { isEmpty } from './validationTypes';
 
 export const useRowOperations = <T extends string>(
   data: RowData<T>[],
   fields: Fields<T>,
   setData: React.Dispatch<React.SetStateAction<RowData<T>[]>>,
   setValidationErrors: React.Dispatch<React.SetStateAction<Map<number, Record<string, ValidationError[]>>>>,
-  validateFieldFromHook: (value: any, field: Field<T>) => ValidationError[]
+  validateFieldFromHook: (value: any, field: Field<T>) => ValidationError[],
+  setValidatingCells?: Dispatch<SetStateAction<Set<string>>>
 ) => {
-  // Uniqueness validation utilities
   const { validateUniqueField } = useUniqueValidation<T>(fields);
 
-  // Determine which field keys are considered uniqueness-constrained
+  const dataRef = useRef(data);
+  useEffect(() => {
+    dataRef.current = data;
+  }, [data]);
+
+  type ValidationTask = { cancel: () => void };
+  const pendingValidationTasksRef = useRef<Map<string, ValidationTask>>(new Map());
+
+  const scheduleIdleTask = useCallback((taskKey: string, runTask: () => void) => {
+    const existingTask = pendingValidationTasksRef.current.get(taskKey);
+    existingTask?.cancel();
+
+    const execute = () => {
+      pendingValidationTasksRef.current.delete(taskKey);
+      runTask();
+    };
+
+    if (typeof window !== 'undefined') {
+      const win = window as Window & typeof globalThis & {
+        requestIdleCallback?: (callback: IdleRequestCallback, options?: IdleRequestOptions) => number;
+        cancelIdleCallback?: (handle: number) => void;
+      };
+
+      if (win.requestIdleCallback) {
+        const handle = win.requestIdleCallback(() => {
+          execute();
+        }, { timeout: 250 });
+
+        pendingValidationTasksRef.current.set(taskKey, {
+          cancel: () => win.cancelIdleCallback?.(handle),
+        });
+        return;
+      }
+
+      const timeoutId = window.setTimeout(execute, 0);
+      pendingValidationTasksRef.current.set(taskKey, {
+        cancel: () => window.clearTimeout(timeoutId),
+      });
+      return;
+    }
+
+    execute();
+  }, []);
+
+  const updateValidatingCell = useCallback(
+    (rowIndex: number, fieldKey: string, pending: boolean) => {
+      if (!setValidatingCells) return;
+      const cellKey = `${rowIndex}-${fieldKey}`;
+      setValidatingCells((prev: Set<string>) => {
+        const hasKey = prev.has(cellKey);
+        if (pending && hasKey) return prev;
+        if (!pending && !hasKey) return prev;
+        const next = new Set(prev);
+        if (pending) next.add(cellKey);
+        else next.delete(cellKey);
+        return next;
+      });
+    },
+    [setValidatingCells]
+  );
+
+  const scheduleFieldValidation = useCallback(
+    (rowIndex: number, fieldKey: string, runValidation: () => void) => {
+      updateValidatingCell(rowIndex, fieldKey, true);
+      try {
+        runValidation();
+      } finally {
+        updateValidatingCell(rowIndex, fieldKey, false);
+      }
+    },
+    [updateValidatingCell]
+  );
+
+  useEffect(() => {
+    return () => {
+      pendingValidationTasksRef.current.forEach((task) => task.cancel());
+      pendingValidationTasksRef.current.clear();
+    };
+  }, []);
+
   const uniquenessFieldKeys = useMemo(() => {
     const keys = new Set<string>([
       'item_number',
@@ -25,15 +104,16 @@ export const useRowOperations = <T extends string>(
       'notions_no',
       'name'
     ]);
-    fields.forEach((f) => {
-      if (f.validations?.some((v) => v.rule === 'unique')) {
-        keys.add(String(f.key));
+
+    fields.forEach((field) => {
+      if (field.validations?.some((v) => v.rule === 'unique')) {
+        keys.add(String(field.key));
       }
     });
+
     return keys;
   }, [fields]);
 
-  // Merge per-field uniqueness errors into the validation error map
   const mergeUniqueErrorsForFields = useCallback(
     (
       baseErrors: Map<number, Record<string, ValidationError[]>>,
@@ -44,26 +124,19 @@ export const useRowOperations = <T extends string>(
 
       const newErrors = new Map(baseErrors);
 
-      // For each field, compute duplicates and merge
       fieldKeysToCheck.forEach((fieldKey) => {
         if (!uniquenessFieldKeys.has(fieldKey)) return;
 
-        // Compute unique errors for this single field
         const uniqueMap = validateUniqueField(dataForCalc, fieldKey);
-
-        // Rows that currently have uniqueness errors for this field
         const rowsWithUniqueErrors = new Set<number>();
         uniqueMap.forEach((_, rowIdx) => rowsWithUniqueErrors.add(rowIdx));
 
-        // First, apply/overwrite unique errors for rows that have duplicates
         uniqueMap.forEach((errorsForRow, rowIdx) => {
           const existing = { ...(newErrors.get(rowIdx) || {}) };
-
-          // Convert InfoWithSource to ValidationError[] for this field
           const info = errorsForRow[fieldKey];
-          // Only apply uniqueness error when the value is non-empty
           const currentValue = (dataForCalc[rowIdx] as any)?.[fieldKey];
-          if (info && !isEmpty(currentValue)) {
+
+          if (info && !isValueEmpty(currentValue)) {
             existing[fieldKey] = [
               {
                 message: info.message,
@@ -78,9 +151,7 @@ export const useRowOperations = <T extends string>(
           else newErrors.delete(rowIdx);
         });
 
-        // Then, remove any stale unique errors for this field where duplicates are resolved
         newErrors.forEach((rowErrs, rowIdx) => {
-          // Skip rows that still have unique errors for this field
           if (rowsWithUniqueErrors.has(rowIdx)) return;
 
           if ((rowErrs as any)[fieldKey]) {
@@ -99,361 +170,372 @@ export const useRowOperations = <T extends string>(
     [uniquenessFieldKeys, validateUniqueField]
   );
 
-  // Helper function to validate a field value
+  const pendingUniqueFieldsRef = useRef<Set<string>>(new Set());
+
+  const runUniqueValidation = useCallback(
+    (fieldsToProcess: string[]) => {
+      if (!fieldsToProcess.length) return;
+      setValidationErrors((prev) =>
+        mergeUniqueErrorsForFields(prev, dataRef.current, fieldsToProcess)
+      );
+    },
+    [mergeUniqueErrorsForFields, setValidationErrors]
+  );
+
+  const scheduleUniqueValidation = useCallback(
+    (fieldKeys: string[]) => {
+      if (!fieldKeys.length) return;
+      const uniqueKeys = fieldKeys.filter((key) => uniquenessFieldKeys.has(key));
+      if (!uniqueKeys.length) return;
+
+      if (pendingUniqueFieldsRef.current.size === 0 && uniqueKeys.length <= 2) {
+        const immediateKeys = Array.from(new Set(uniqueKeys));
+        runUniqueValidation(immediateKeys);
+        return;
+      }
+
+      uniqueKeys.forEach((fieldKey) => pendingUniqueFieldsRef.current.add(fieldKey));
+
+      scheduleIdleTask('unique:batch', () => {
+        const fieldsToProcess = Array.from(pendingUniqueFieldsRef.current);
+        pendingUniqueFieldsRef.current.clear();
+        if (!fieldsToProcess.length) return;
+        runUniqueValidation(fieldsToProcess);
+      });
+    },
+    [runUniqueValidation, scheduleIdleTask, uniquenessFieldKeys]
+  );
+
   const fieldValidationHelper = useCallback(
     (rowIndex: number, specificField?: string) => {
-      // Skip validation if row doesn't exist
-      if (rowIndex < 0 || rowIndex >= data.length) return;
+      const currentData = dataRef.current;
+      if (rowIndex < 0 || rowIndex >= currentData.length) return;
 
-      // Get the row data
-      const row = data[rowIndex];
+     const row = currentData[rowIndex];
 
-      // If validating a specific field, only check that field
       if (specificField) {
         const field = fields.find((f) => String(f.key) === specificField);
-        if (field) {
-          const value = row[specificField as keyof typeof row];
+        if (!field) return;
 
-          // Use state setter instead of direct mutation
-          setValidationErrors((prev) => {
-            let newErrors = new Map(prev);
-            const existingErrors = { ...(newErrors.get(rowIndex) || {}) };
+        const value = row[specificField as keyof typeof row];
 
-            // Quick check for required fields - this prevents flashing errors
-            const isRequired = field.validations?.some(
-              (v) => v.rule === "required"
-            );
-            const isEmpty =
-              value === undefined ||
-              value === null ||
-              value === "" ||
-              (Array.isArray(value) && value.length === 0) ||
-              (typeof value === "object" &&
-                value !== null &&
-                Object.keys(value).length === 0);
-
-            // For non-empty values, remove required errors immediately
-            if (isRequired && !isEmpty && existingErrors[specificField]) {
-              const nonRequiredErrors = existingErrors[specificField].filter(
-                (e) => e.type !== ErrorType.Required
-              );
-              if (nonRequiredErrors.length === 0) {
-                // If no other errors, remove the field entirely from errors
-                delete existingErrors[specificField];
-              } else {
-                existingErrors[specificField] = nonRequiredErrors;
-              }
-            }
-
-            // Run full validation for the field
-            const errors = validateFieldFromHook(value, field as unknown as Field<T>);
-
-            // Update validation errors for this field
-            if (errors.length > 0) {
-              existingErrors[specificField] = errors;
-            } else {
-              delete existingErrors[specificField];
-            }
-
-            // Update validation errors map
-            if (Object.keys(existingErrors).length > 0) {
-              newErrors.set(rowIndex, existingErrors);
-            } else {
-              newErrors.delete(rowIndex);
-            }
-
-            // If field is uniqueness-constrained, also re-validate uniqueness for the column
-            if (uniquenessFieldKeys.has(specificField)) {
-              const dataForCalc = data; // latest data
-              newErrors = mergeUniqueErrorsForFields(newErrors, dataForCalc, [specificField]);
-            }
-
-            return newErrors;
-          });
-        }
-      } else {
-        // Validate all fields in the row
+        updateValidatingCell(rowIndex, specificField, true);
         setValidationErrors((prev) => {
-          const newErrors = new Map(prev);
-          const rowErrors: Record<string, ValidationError[]> = {};
+          const existingErrors = prev.get(rowIndex) || {};
+          const newRowErrors = { ...existingErrors };
+          let rowChanged = false;
 
-          fields.forEach((field) => {
+          const isRequired = field.validations?.some((v) => v.rule === 'required');
+          const valueIsEmpty =
+            value === undefined ||
+            value === null ||
+            value === '' ||
+            (Array.isArray(value) && value.length === 0) ||
+            (typeof value === 'object' && value !== null && Object.keys(value).length === 0);
+
+          if (isRequired && !valueIsEmpty && newRowErrors[specificField]) {
+            const nonRequiredErrors = newRowErrors[specificField].filter((e) => e.type !== ErrorType.Required);
+
+            if (nonRequiredErrors.length === 0) {
+              rowChanged = true;
+              delete newRowErrors[specificField];
+            } else if (nonRequiredErrors.length !== newRowErrors[specificField].length) {
+              rowChanged = true;
+              newRowErrors[specificField] = nonRequiredErrors;
+            }
+          }
+
+          const errors = validateFieldFromHook(value, field as unknown as Field<T>);
+
+          if (errors.length > 0) {
+            const existing = newRowErrors[specificField] || [];
+            const sameLength = existing.length === errors.length;
+            const sameContent = sameLength && existing.every((err, idx) => err.message === errors[idx].message && err.type === errors[idx].type);
+            if (!sameContent) {
+              rowChanged = true;
+              newRowErrors[specificField] = errors;
+            }
+          } else if (newRowErrors[specificField]) {
+            rowChanged = true;
+            delete newRowErrors[specificField];
+          }
+
+          let resultMap = prev;
+          if (rowChanged) {
+            resultMap = new Map(prev);
+            if (Object.keys(newRowErrors).length > 0) {
+              resultMap.set(rowIndex, newRowErrors);
+            } else {
+              resultMap.delete(rowIndex);
+            }
+          }
+
+          if (uniquenessFieldKeys.has(specificField)) {
+            scheduleUniqueValidation([specificField]);
+            return rowChanged ? resultMap : prev;
+          }
+
+          return rowChanged ? resultMap : prev;
+        });
+        updateValidatingCell(rowIndex, specificField, false);
+      } else {
+        setValidationErrors((prev) => {
+            const rowErrors: Record<string, ValidationError[]> = {};
+
+            fields.forEach((field) => {
             const fieldKey = String(field.key);
-            const value = row[fieldKey as keyof typeof row];
-            const errors = validateFieldFromHook(value, field as unknown as Field<T>);
-
+            const valueForField = row[fieldKey as keyof typeof row];
+            const errors = validateFieldFromHook(valueForField, field as unknown as Field<T>);
             if (errors.length > 0) {
               rowErrors[fieldKey] = errors;
             }
           });
 
-          // Update validation errors map
-          if (Object.keys(rowErrors).length > 0) {
-            newErrors.set(rowIndex, rowErrors);
-          } else {
-            newErrors.delete(rowIndex);
+          if (Object.keys(rowErrors).length === 0) {
+            if (!prev.has(rowIndex)) return prev;
+            const result = new Map(prev);
+            result.delete(rowIndex);
+            return result;
           }
 
-          return newErrors;
-        });
+          const existing = prev.get(rowIndex);
+          const sameEntries = existing && Object.keys(rowErrors).length === Object.keys(existing).length && Object.entries(rowErrors).every(([key, val]) => {
+            const existingVal = existing[key];
+            return (
+              existingVal &&
+              existingVal.length === val.length &&
+              existingVal.every((err, idx) => err.message === val[idx].message && err.type === val[idx].type)
+            );
+          });
+
+          if (sameEntries) return prev;
+
+          const result = new Map(prev);
+          result.set(rowIndex, rowErrors);
+          return result;
+          });
+        const uniqueKeys = fields
+          .map((field) => String(field.key))
+          .filter((fieldKey) => uniquenessFieldKeys.has(fieldKey));
+        if (uniqueKeys.length > 0) {
+          scheduleUniqueValidation(uniqueKeys);
+        }
       }
     },
-    [data, fields, validateFieldFromHook, setValidationErrors, mergeUniqueErrorsForFields, uniquenessFieldKeys]
+    [fields, scheduleUniqueValidation, setValidationErrors, uniquenessFieldKeys, validateFieldFromHook]
   );
 
-  // Use validateRow as an alias for fieldValidationHelper for compatibility
   const validateRow = fieldValidationHelper;
 
-  // Modified updateRow function that properly handles field-specific validation
   const updateRow = useCallback(
     (rowIndex: number, key: T, value: any) => {
-      // Process value before updating data
       let processedValue = value;
 
-      // Strip dollar signs from price fields
-      if (
-        (key === "msrp" || key === "cost_each") &&
-        typeof value === "string"
-      ) {
-        processedValue = value.replace(/[$,]/g, "");
-
-        // Also ensure it's a valid number
+      if ((key === 'msrp' || key === 'cost_each') && typeof value === 'string') {
+        processedValue = value.replace(/[$,]/g, '');
         const numValue = parseFloat(processedValue);
-        if (!isNaN(numValue)) {
+        if (!Number.isNaN(numValue)) {
           processedValue = numValue.toFixed(2);
         }
       }
 
-      // Find the row data first
-      const rowData = data[rowIndex];
+      const currentData = dataRef.current;
+      const rowData = currentData[rowIndex];
       if (!rowData) {
         console.error(`No row data found for index ${rowIndex}`);
         return;
       }
 
-      // Create a copy of the row to avoid mutation
       const updatedRow = { ...rowData, [key]: processedValue };
 
-      // Update the data immediately - this sets the value
-      setData((prevData) => {
-        const newData = [...prevData];
-        if (rowIndex >= 0 && rowIndex < newData.length) {
-          newData[rowIndex] = updatedRow;
-        }
-        return newData;
+      const nextData = [...currentData];
+      if (rowIndex >= 0 && rowIndex < nextData.length) {
+        nextData[rowIndex] = updatedRow;
+      }
+      dataRef.current = nextData;
+
+      startTransition(() => {
+        setData(() => nextData);
       });
 
-      // Find the field definition
       const field = fields.find((f) => String(f.key) === key);
       if (!field) return;
 
-      // CRITICAL FIX: Combine both validation operations into a single state update
-      // to prevent intermediate rendering that causes error icon flashing
-      setValidationErrors((prev) => {
-        // Start with previous errors
-        let newMap = new Map(prev);
-        const existingErrors = newMap.get(rowIndex) || {};
-        const newRowErrors = { ...existingErrors };
+      scheduleFieldValidation(rowIndex, String(key), () => {
+        setValidationErrors((prev) => {
+            const existingErrors = prev.get(rowIndex) || {};
+            const newRowErrors = { ...existingErrors };
+            let rowChanged = false;
 
-        // Check for required field first
-        const isRequired = field.validations?.some(
-          (v) => v.rule === "required"
-        );
-        const isEmpty =
-          processedValue === undefined ||
-          processedValue === null ||
-          processedValue === "" ||
-          (Array.isArray(processedValue) && processedValue.length === 0) ||
-          (typeof processedValue === "object" &&
-            processedValue !== null &&
-            Object.keys(processedValue).length === 0);
+          const latestRow = dataRef.current[rowIndex];
+          const currentValue = latestRow ? (latestRow[String(key) as keyof typeof latestRow] as unknown) : processedValue;
 
-        // For required fields with values, remove required errors
-        if (isRequired && !isEmpty && newRowErrors[key as string]) {
-          const hasRequiredError = newRowErrors[key as string].some(
-            (e) => e.type === ErrorType.Required
-          );
-
-          if (hasRequiredError) {
-            // Remove required errors but keep other types of errors
-            const nonRequiredErrors = newRowErrors[key as string].filter(
-              (e) => e.type !== ErrorType.Required
-            );
+          const isRequired = field.validations?.some((v) => v.rule === 'required');
+          const valueIsEmpty =
+            currentValue === undefined ||
+            currentValue === null ||
+            currentValue === '' ||
+            (Array.isArray(currentValue) && currentValue.length === 0) ||
+            (typeof currentValue === 'object' && currentValue !== null && Object.keys(currentValue).length === 0);
 
+          if (isRequired && !valueIsEmpty && newRowErrors[String(key)]) {
+            const nonRequiredErrors = newRowErrors[String(key)].filter((e) => e.type !== ErrorType.Required);
             if (nonRequiredErrors.length === 0) {
-              // If no other errors, delete the field's errors entirely
-              delete newRowErrors[key as string];
-            } else {
-              // Otherwise keep non-required errors
-              newRowErrors[key as string] = nonRequiredErrors;
+              if (newRowErrors[String(key)]) {
+                rowChanged = true;
+                delete newRowErrors[String(key)];
+              }
+            } else if (nonRequiredErrors.length !== newRowErrors[String(key)].length) {
+              rowChanged = true;
+              newRowErrors[String(key)] = nonRequiredErrors;
             }
           }
+
+          const errors = validateFieldFromHook(
+            currentValue,
+            field as unknown as Field<T>
+          ).filter((e) => e.type !== ErrorType.Required || valueIsEmpty);
+
+          if (errors.length > 0) {
+            const existing = newRowErrors[String(key)] || [];
+            const sameLength = existing.length === errors.length;
+            const sameContent = sameLength && existing.every((err, idx) => err.message === errors[idx].message && err.type === errors[idx].type);
+            if (!sameContent) {
+              rowChanged = true;
+              newRowErrors[String(key)] = errors;
+            }
+          } else if (newRowErrors[String(key)]) {
+            rowChanged = true;
+            delete newRowErrors[String(key)];
+          }
+
+          let resultMap = prev;
+          if (rowChanged) {
+            resultMap = new Map(prev);
+            if (Object.keys(newRowErrors).length > 0) {
+              resultMap.set(rowIndex, newRowErrors);
+            } else {
+              resultMap.delete(rowIndex);
+            }
+          }
+
+          const fieldsToCheck: string[] = [];
+          if (uniquenessFieldKeys.has(String(key))) fieldsToCheck.push(String(key));
+          if (key === ('upc' as T) || key === ('barcode' as T) || key === ('supplier' as T)) {
+            if (uniquenessFieldKeys.has('item_number')) fieldsToCheck.push('item_number');
+          }
+
+          if (fieldsToCheck.length > 0) {
+            scheduleUniqueValidation(fieldsToCheck);
+          }
+
+            return rowChanged ? resultMap : prev;
+          });
+      });
+
+      setTimeout(() => {
+        const rowId = rowData.__index;
+
+        if (key === 'company' && processedValue) {
+          const nextData = [...dataRef.current];
+          const idx = nextData.findIndex((item) => item.__index === rowId);
+          if (idx >= 0) {
+            nextData[idx] = {
+              ...nextData[idx],
+              line: undefined,
+              subline: undefined,
+            };
+            dataRef.current = nextData;
+            startTransition(() => {
+              setData(() => nextData);
+            });
+          }
         }
 
-        // Now run full validation for the field (except for required which we already handled)
-        const errors = validateFieldFromHook(
-          processedValue,
-          field as unknown as Field<T>
-        ).filter((e) => e.type !== ErrorType.Required || isEmpty);
-
-        // Update with new validation results
-        if (errors.length > 0) {
-          newRowErrors[key as string] = errors;
-        } else {
-          // Clear any existing errors for this field
-          delete newRowErrors[key as string];
+        if (key === 'line' && processedValue) {
+          const nextData = [...dataRef.current];
+          const idx = nextData.findIndex((item) => item.__index === rowId);
+          if (idx >= 0) {
+            nextData[idx] = {
+              ...nextData[idx],
+              subline: undefined,
+            };
+            dataRef.current = nextData;
+            startTransition(() => {
+              setData(() => nextData);
+            });
+          }
         }
-
-        // Update the map
-        if (Object.keys(newRowErrors).length > 0) {
-          newMap.set(rowIndex, newRowErrors);
-        } else {
-          newMap.delete(rowIndex);
-        }
-
-        // If uniqueness applies, validate affected columns
-        const fieldsToCheck: string[] = [];
-        if (uniquenessFieldKeys.has(String(key))) fieldsToCheck.push(String(key));
-        if (key === ('upc' as T) || key === ('barcode' as T) || key === ('supplier' as T)) {
-          if (uniquenessFieldKeys.has('item_number')) fieldsToCheck.push('item_number');
-        }
-
-        if (fieldsToCheck.length > 0) {
-          const dataForCalc = (() => {
-            const copy = [...data];
-            if (rowIndex >= 0 && rowIndex < copy.length) {
-              copy[rowIndex] = { ...(copy[rowIndex] || {}), [key]: processedValue } as RowData<T>;
-            }
-            return copy;
-          })();
-          newMap = mergeUniqueErrorsForFields(newMap, dataForCalc, fieldsToCheck);
-        }
-
-        return newMap;
-      });
-
-      // Handle simple secondary effects here
-      setTimeout(() => {
-        // Use __index to find the actual row in the full data array
-        const rowId = rowData.__index;
-
-        // Handle company change - clear line/subline
-        if (key === "company" && processedValue) {
-          // Clear any existing line/subline values
-          setData((prevData) => {
-            const newData = [...prevData];
-            const idx = newData.findIndex((item) => item.__index === rowId);
-            if (idx >= 0) {
-              newData[idx] = {
-                ...newData[idx],
-                line: undefined,
-                subline: undefined,
-              };
-            }
-            return newData;
-          });
-        }
-
-        // Handle line change - clear subline
-        if (key === "line" && processedValue) {
-          // Clear any existing subline value
-          setData((prevData) => {
-            const newData = [...prevData];
-            const idx = newData.findIndex((item) => item.__index === rowId);
-            if (idx >= 0) {
-              newData[idx] = {
-                ...newData[idx],
-                subline: undefined,
-              };
-            }
-            return newData;
-          });
-        }
-      }, 5); // Reduced delay for faster secondary effects
+      }, 5);
     },
-    [data, fields, validateFieldFromHook, setData, setValidationErrors, mergeUniqueErrorsForFields, uniquenessFieldKeys]
+    [fields, scheduleFieldValidation, scheduleUniqueValidation, setData, setValidationErrors, uniquenessFieldKeys, validateFieldFromHook]
   );
 
-  // Improved revalidateRows function
   const revalidateRows = useCallback(
     async (
       rowIndexes: number[],
       updatedFields?: { [rowIndex: number]: string[] }
     ) => {
-      // Process all specified rows using a single state update to avoid race conditions
+      const uniqueFieldsToCheck = new Set<string>();
+      const fieldsMarked: Array<[number, string]> = [];
+
       setValidationErrors((prev) => {
         let newErrors = new Map(prev);
+        const currentData = dataRef.current;
 
-        // Track which uniqueness fields need to be revalidated across the dataset
-        const uniqueFieldsToCheck = new Set<string>();
-
-        // Process each row
         for (const rowIndex of rowIndexes) {
-          if (rowIndex < 0 || rowIndex >= data.length) continue;
-
-          const row = data[rowIndex];
+          if (rowIndex < 0 || rowIndex >= currentData.length) continue;
+          const row = currentData[rowIndex];
           if (!row) continue;
 
-          // If we have specific fields to update for this row
           const fieldsToValidate = updatedFields?.[rowIndex] || [];
 
           if (fieldsToValidate.length > 0) {
-            // Get existing errors for this row
             const existingRowErrors = { ...(newErrors.get(rowIndex) || {}) };
 
-            // Validate each specified field
             for (const fieldKey of fieldsToValidate) {
               const field = fields.find((f) => String(f.key) === fieldKey);
               if (!field) continue;
 
-              const value = row[fieldKey as keyof typeof row];
+              updateValidatingCell(rowIndex, fieldKey, true);
+              fieldsMarked.push([rowIndex, fieldKey]);
 
-              // Run validation for this field
+              const value = row[fieldKey as keyof typeof row];
               const errors = validateFieldFromHook(value, field as unknown as Field<T>);
 
-              // Update errors for this field
               if (errors.length > 0) {
                 existingRowErrors[fieldKey] = errors;
               } else {
                 delete existingRowErrors[fieldKey];
               }
 
-              // If field is uniqueness-constrained, mark for uniqueness pass
               if (uniquenessFieldKeys.has(fieldKey)) {
                 uniqueFieldsToCheck.add(fieldKey);
               }
             }
 
-            // Update the row's errors
             if (Object.keys(existingRowErrors).length > 0) {
               newErrors.set(rowIndex, existingRowErrors);
             } else {
               newErrors.delete(rowIndex);
             }
           } else {
-            // No specific fields provided - validate the entire row
             const rowErrors: Record<string, ValidationError[]> = {};
 
-            // Validate all fields in the row
             for (const field of fields) {
               const fieldKey = String(field.key);
               const value = row[fieldKey as keyof typeof row];
-
-              // Run validation for this field
               const errors = validateFieldFromHook(value, field as unknown as Field<T>);
 
-              // Update errors for this field
               if (errors.length > 0) {
                 rowErrors[fieldKey] = errors;
               }
 
-              // If field is uniqueness-constrained and we validated it, include for uniqueness pass
               if (uniquenessFieldKeys.has(fieldKey)) {
                 uniqueFieldsToCheck.add(fieldKey);
               }
             }
 
-            // Update the row's errors
             if (Object.keys(rowErrors).length > 0) {
               newErrors.set(rowIndex, rowErrors);
             } else {
@@ -462,31 +544,40 @@ export const useRowOperations = <T extends string>(
           }
         }
 
-        // Run per-field uniqueness checks and merge results
-        if (uniqueFieldsToCheck.size > 0) {
-          newErrors = mergeUniqueErrorsForFields(newErrors, data, Array.from(uniqueFieldsToCheck));
-        }
-
         return newErrors;
       });
+
+      fieldsMarked.forEach(([rowIndex, fieldKey]) => {
+        updateValidatingCell(rowIndex, fieldKey, false);
+      });
+
+      if (uniqueFieldsToCheck.size > 0) {
+        scheduleUniqueValidation(Array.from(uniqueFieldsToCheck));
+      }
     },
-    [data, fields, validateFieldFromHook, mergeUniqueErrorsForFields, uniquenessFieldKeys]
+    [
+      fields,
+      scheduleUniqueValidation,
+      setValidationErrors,
+      uniquenessFieldKeys,
+      validateFieldFromHook,
+      updateValidatingCell
+    ]
   );
 
-  // Copy a cell value to all cells below it in the same column
   const copyDown = useCallback(
     (rowIndex: number, key: T) => {
-      // Get the source value to copy
-      const sourceValue = data[rowIndex][key];
+      const currentData = dataRef.current;
+      const sourceRow = currentData[rowIndex];
+      if (!sourceRow) return;
 
-      // Update all rows below with the same value using the existing updateRow function
-      // This ensures all validation logic runs consistently
-      for (let i = rowIndex + 1; i < data.length; i++) {
-        // Just use updateRow which will handle validation with proper timing
+      const sourceValue = sourceRow[key];
+
+      for (let i = rowIndex + 1; i < currentData.length; i++) {
         updateRow(i, key, sourceValue);
       }
     },
-    [data, updateRow]
+    [updateRow]
   );
 
   return {
@@ -495,4 +586,4 @@ export const useRowOperations = <T extends string>(
     revalidateRows,
     copyDown
   };
-}; 
+};

inventory/src/components/product-import/steps/ValidationStepNew/hooks/useValidationState.tsx

@@ -1,4 +1,4 @@
-import { useState, useEffect, useCallback, useMemo, useRef } from "react";
+import { useState, useEffect, useCallback, useMemo, useRef, startTransition } from "react";
 import { useRsi } from "../../../hooks/useRsi";
 import { ErrorType } from "../../../types";
 import { RowSelectionState } from "@tanstack/react-table";
@@ -11,7 +11,7 @@ import { useTemplateManagement } from "./useTemplateManagement";
 import { useFilterManagement } from "./useFilterManagement";
 import { useUniqueItemNumbersValidation } from "./useUniqueItemNumbersValidation";
 import { useUpcValidation } from "./useUpcValidation";
-import { Props, RowData } from "./validationTypes";
+import { Props, RowData, isEmpty as isValueEmpty } from "./validationTypes";
 
 // Country normalization helper (common mappings) - function declaration for hoisting
 function normalizeCountryCode(input: string): string | null {
@@ -145,6 +145,7 @@ export const useValidationState = <T extends string>({
   // isValidatingRef unused; remove to satisfy TS
   // Track last seen item_number signature to drive targeted uniqueness checks
   const lastItemNumberSigRef = useRef<string | null>(null);
+  const pendingItemNumberValidationRef = useRef<{ cancel: () => void } | null>(null);
 
   // Use row operations hook
   const { validateRow, updateRow, revalidateRows, copyDown } = useRowOperations<T>(
@@ -152,7 +153,8 @@ export const useValidationState = <T extends string>({
     fields,
     setData,
     setValidationErrors,
-    validateFieldFromHook
+    validateFieldFromHook,
+    setValidatingCells
   );
 
   // Use UPC validation hook - MUST be initialized before template management
@@ -306,313 +308,325 @@ export const useValidationState = <T extends string>({
   // Initialize validation once, after initial UPC-based item number generation completes
   useEffect(() => {
     if (initialValidationDoneRef.current) return;
-    // Wait for initial UPC validation to finish to avoid double work and ensure
-    // item_number values are in place before uniqueness checks
     if (!upcValidation.initialValidationDone) return;
+    if (!data || data.length === 0) return;
 
-    const runCompleteValidation = async () => {
-      if (!data || data.length === 0) return;
+    const requiredFields = fields.filter((field) =>
+      field.validations?.some((v) => v.rule === "required")
+    );
+    const regexFields = fields.filter((field) =>
+      field.validations?.some((v) => v.rule === "regex")
+    );
 
-      console.log("Running complete validation...");
+    const validationErrorsTemp = new Map<number, Record<string, any[]>>();
+    const mutatedRows: Array<[number, RowData<T>]> = [];
+    const totalRows = data.length;
+    let currentIndex = 0;
+    let cancelled = false;
 
-      // Get required fields
-      const requiredFields = fields.filter((field) =>
-        field.validations?.some((v) => v.rule === "required")
-      );
-      console.log(`Found ${requiredFields.length} required fields`);
+    const cleanupCallbacks = new Set<() => void>();
 
-      // Get fields that have regex validation
-      const regexFields = fields.filter((field) =>
-        field.validations?.some((v) => v.rule === "regex")
-      );
-      console.log(`Found ${regexFields.length} fields with regex validation`);
+    const processRow = (rowIndex: number) => {
+      const row = data[rowIndex];
+      if (!row) return;
 
-      // Get fields that need uniqueness validation
-      const uniqueFields = fields.filter((field) =>
-        field.validations?.some((v) => v.rule === "unique")
-      );
-      console.log(
-        `Found ${uniqueFields.length} fields requiring uniqueness validation`
-      );
+      const rowErrors: Record<string, any[]> = {};
+      let hasErrors = false;
 
-      // Dynamic batch size based on dataset size
-      const BATCH_SIZE = data.length <= 50 ? data.length : 25; // Process all at once for small datasets
-      const totalRows = data.length;
+      const rowAsRecord = row as Record<string, any>;
+      let updatedRow: Record<string, any> | null = null;
 
-      // Initialize new data for any modifications
-      const newData = [...data];
-
-      // Create a temporary Map to collect all validation errors
-      const validationErrorsTemp = new Map<
-        number,
-        Record<string, any[]>
-      >();
-
-      // Variables for batching
-      let currentBatch = 0;
-      const totalBatches = Math.ceil(totalRows / BATCH_SIZE);
-
-      const processBatch = async () => {
-        // Calculate batch range
-        const startIdx = currentBatch * BATCH_SIZE;
-        const endIdx = Math.min(startIdx + BATCH_SIZE, totalRows);
-        console.log(
-          `Processing batch ${
-            currentBatch + 1
-          }/${totalBatches} (rows ${startIdx} to ${endIdx - 1})`
-        );
-
-        // Process rows in this batch
-        const batchPromises: Promise<void>[] = [];
-
-        for (let rowIndex = startIdx; rowIndex < endIdx; rowIndex++) {
-          batchPromises.push(
-            new Promise<void>((resolve) => {
-              const row = data[rowIndex];
-
-              // Skip if row is empty or undefined
-              if (!row) {
-                resolve();
-                return;
-              }
-
-              // Store field errors for this row
-              const fieldErrors: Record<string, any[]> = {};
-              let hasErrors = false;
-
-              // Check if price fields need formatting
-              const rowAsRecord = row as Record<string, any>;
-              let mSrpNeedsProcessing = false;
-              let costEachNeedsProcessing = false;
-
-              if (
-                rowAsRecord.msrp &&
-                typeof rowAsRecord.msrp === "string" &&
-                (rowAsRecord.msrp.includes("$") ||
-                  rowAsRecord.msrp.includes(","))
-              ) {
-                mSrpNeedsProcessing = true;
-              }
-
-              if (
-                rowAsRecord.cost_each &&
-                typeof rowAsRecord.cost_each === "string" &&
-                (rowAsRecord.cost_each.includes("$") ||
-                  rowAsRecord.cost_each.includes(","))
-              ) {
-                costEachNeedsProcessing = true;
-              }
-
-              // Process price fields if needed
-              if (mSrpNeedsProcessing || costEachNeedsProcessing) {
-                // Create a clean copy only if needed
-                const cleanedRow = { ...row } as Record<string, any>;
-
-                if (mSrpNeedsProcessing) {
-                  const msrpValue = rowAsRecord.msrp.replace(/[$,]/g, "");
-                  const numValue = parseFloat(msrpValue);
-                  cleanedRow.msrp = !isNaN(numValue)
-                    ? numValue.toFixed(2)
-                    : msrpValue;
-                }
-
-                if (costEachNeedsProcessing) {
-                  const costValue = rowAsRecord.cost_each.replace(/[$,]/g, "");
-                  const numValue = parseFloat(costValue);
-                  cleanedRow.cost_each = !isNaN(numValue)
-                    ? numValue.toFixed(2)
-                    : costValue;
-                }
-
-                newData[rowIndex] = cleanedRow as RowData<T>;
-              }
-
-              // Validate required fields
-              for (const field of requiredFields) {
-                const key = String(field.key);
-                const value = row[key as keyof typeof row];
-
-                // Skip non-required empty fields
-                if (
-                  value === undefined ||
-                  value === null ||
-                  value === "" ||
-                  (Array.isArray(value) && value.length === 0) ||
-                  (typeof value === "object" &&
-                    value !== null &&
-                    Object.keys(value).length === 0)
-                ) {
-                  // Add error for empty required fields
-                  fieldErrors[key] = [
-                    {
-                      message:
-                        field.validations?.find((v) => v.rule === "required")
-                          ?.errorMessage || "This field is required",
-                      level: "error",
-                      source: "row",
-                      type: "required",
-                    },
-                  ];
-                  hasErrors = true;
-                }
-              }
-
-              // Validate regex fields - even if they have data
-              for (const field of regexFields) {
-                const key = String(field.key);
-                const value = row[key as keyof typeof row];
-
-                // Skip empty values as they're handled by required validation
-                if (value === undefined || value === null || value === "") {
-                  continue;
-                }
-
-                // Find regex validation
-                const regexValidation = field.validations?.find(
-                  (v) => v.rule === "regex"
-                );
-                if (regexValidation) {
-                  try {
-                    // Check if value matches regex
-                    const regex = new RegExp(
-                      regexValidation.value,
-                      regexValidation.flags
-                    );
-                    if (!regex.test(String(value))) {
-                      // Add regex validation error
-                      fieldErrors[key] = [
-                        {
-                          message: regexValidation.errorMessage,
-                          level: regexValidation.level || "error",
-                          source: "row",
-                          type: "regex",
-                        },
-                      ];
-                      hasErrors = true;
-                    }
-                  } catch (error) {
-                    console.error("Invalid regex in validation:", error);
-                  }
-                }
-              }
-
-              // Update validation errors for this row
-              if (hasErrors) {
-                validationErrorsTemp.set(rowIndex, fieldErrors);
-              }
-
-              resolve();
-            })
-          );
+      const ensureUpdatedRow = () => {
+        if (!updatedRow) {
+          updatedRow = { ...rowAsRecord };
         }
-
-        // Wait for all row validations to complete
-        await Promise.all(batchPromises);
+        return updatedRow;
       };
 
-      const processAllBatches = async () => {
-        for (let batch = 0; batch < totalBatches; batch++) {
-          currentBatch = batch;
-          await processBatch();
+      if (typeof rowAsRecord.msrp === "string" && /[$,]/.test(rowAsRecord.msrp)) {
+        const msrpValue = rowAsRecord.msrp.replace(/[$,]/g, "");
+        const numValue = parseFloat(msrpValue);
+        ensureUpdatedRow().msrp = Number.isNaN(numValue) ? msrpValue : numValue.toFixed(2);
+      }
 
-          // Yield to UI thread more frequently for large datasets
-          if (batch % 2 === 1 || totalRows > 500) {
-            await new Promise((resolve) => setTimeout(resolve, totalRows > 1000 ? 10 : 5));
+      if (typeof rowAsRecord.cost_each === "string" && /[$,]/.test(rowAsRecord.cost_each)) {
+        const costValue = rowAsRecord.cost_each.replace(/[$,]/g, "");
+        const numValue = parseFloat(costValue);
+        ensureUpdatedRow().cost_each = Number.isNaN(numValue) ? costValue : numValue.toFixed(2);
+      }
+
+      for (const field of requiredFields) {
+        const key = String(field.key);
+        const value = rowAsRecord[key];
+
+        if (isValueEmpty(value)) {
+          rowErrors[key] = [
+            {
+              message:
+                field.validations?.find((v) => v.rule === "required")?.errorMessage ||
+                "This field is required",
+              level: "error",
+              source: "row",
+              type: "required",
+            },
+          ];
+          hasErrors = true;
+        }
+      }
+
+      for (const field of regexFields) {
+        const key = String(field.key);
+        const value = rowAsRecord[key];
+        if (value === undefined || value === null || value === "") continue;
+
+        const regexValidation = field.validations?.find((v) => v.rule === "regex");
+        if (!regexValidation) continue;
+
+        try {
+          const regex = new RegExp(regexValidation.value, regexValidation.flags);
+          if (!regex.test(String(value))) {
+            rowErrors[key] = [
+              {
+                message: regexValidation.errorMessage,
+                level: regexValidation.level || "error",
+                source: "row",
+                type: "regex",
+              },
+            ];
+            hasErrors = true;
           }
+        } catch (error) {
+          console.error("Invalid regex in validation:", error);
         }
+      }
 
-        // All batches complete
-        console.log("All initial validation batches complete");
+      if (updatedRow) {
+        mutatedRows.push([rowIndex, updatedRow as RowData<T>]);
+      }
 
-        // Apply collected validation errors all at once
-        setValidationErrors(validationErrorsTemp);
-
-        // Apply any data changes (like price formatting)
-        if (JSON.stringify(data) !== JSON.stringify(newData)) {
-          setData(newData);
-        }
-
-        // Run uniqueness validation after the basic validation
-        validateUniqueItemNumbers();
-
-        // Mark that initial validation is done
-        initialValidationDoneRef.current = true;
-
-        console.log("Initial validation complete");
-      };
-
-      // Start the validation process
-      processAllBatches();
+      if (hasErrors) {
+        validationErrorsTemp.set(rowIndex, rowErrors);
+      }
     };
 
-    // Run the complete validation
-    runCompleteValidation();
+    const finalize = () => {
+      if (cancelled) return;
+
+      startTransition(() => {
+        setValidationErrors(new Map(validationErrorsTemp));
+      });
+
+      if (mutatedRows.length > 0) {
+        setData((prev) => {
+          if (cancelled) return prev;
+          let applied = false;
+          const next = [...prev];
+
+          mutatedRows.forEach(([index, updatedRow]) => {
+            if (index < 0 || index >= prev.length) return;
+            if (prev[index] !== data[index]) return;
+            next[index] = updatedRow;
+            applied = true;
+          });
+
+          return applied ? next : prev;
+        });
+      }
+
+      validateUniqueItemNumbers();
+      initialValidationDoneRef.current = true;
+    };
+
+    const runChunk = (deadline?: IdleDeadline) => {
+      if (cancelled) return;
+
+      let iterations = 0;
+      const maxIterationsPerChunk = 20;
+
+      while (currentIndex < totalRows) {
+        if (deadline) {
+          if (deadline.timeRemaining() <= 0 && iterations > 0) break;
+        } else if (iterations >= maxIterationsPerChunk) {
+          break;
+        }
+
+        processRow(currentIndex);
+        currentIndex += 1;
+        iterations += 1;
+      }
+
+      if (currentIndex >= totalRows) {
+        finalize();
+        return;
+      }
+
+      scheduleNext();
+    };
+
+    const scheduleNext = () => {
+      if (cancelled) return;
+
+      if (typeof window !== 'undefined') {
+        const win = window as Window & typeof globalThis & {
+          requestIdleCallback?: (callback: IdleRequestCallback, options?: IdleRequestOptions) => number;
+          cancelIdleCallback?: (handle: number) => void;
+        };
+
+        if (win.requestIdleCallback) {
+          let cancel: () => void = () => {};
+          const handle = win.requestIdleCallback((deadline) => {
+            cleanupCallbacks.delete(cancel);
+            runChunk(deadline);
+          }, { timeout: 250 });
+          cancel = () => win.cancelIdleCallback?.(handle);
+          cleanupCallbacks.add(cancel);
+          return;
+        }
+
+        let cancel: () => void = () => {};
+        const timeoutId = window.setTimeout(() => {
+          cleanupCallbacks.delete(cancel);
+          runChunk();
+        }, 16);
+        cancel = () => window.clearTimeout(timeoutId);
+        cleanupCallbacks.add(cancel);
+        return;
+      }
+
+      setTimeout(() => runChunk(), 0);
+    };
+
+    scheduleNext();
+
+    return () => {
+      cancelled = true;
+      cleanupCallbacks.forEach((cancel) => cancel());
+      cleanupCallbacks.clear();
+    };
   }, [data, fields, setData, setValidationErrors, validateUniqueItemNumbers, upcValidation.initialValidationDone]);
 
   // Targeted uniqueness revalidation: run only when item_number values change
   useEffect(() => {
     if (!data || data.length === 0) return;
 
-    // Build a simple signature of the item_number column
-    const sig = data.map((r) => String((r as Record<string, any>).item_number ?? '')).join('|');
+    const sig = data
+      .map((r) => String((r as Record<string, any>).item_number ?? ''))
+      .join('|');
     if (lastItemNumberSigRef.current === sig) return;
     lastItemNumberSigRef.current = sig;
 
-    // Compute unique errors for item_number only and merge
-    const uniqueMap = validateUniqueField(data, 'item_number');
-    const rowsWithUnique = new Set<number>();
-    uniqueMap.forEach((_, idx) => rowsWithUnique.add(idx));
+    pendingItemNumberValidationRef.current?.cancel();
 
-    setValidationErrors((prev) => {
-      const newMap = new Map(prev);
+    let cancelled = false;
+    const currentData = data;
 
-      // Apply unique errors
-      uniqueMap.forEach((errorsForRow, rowIdx) => {
-        const existing = { ...(newMap.get(rowIdx) || {}) } as Record<string, any[]>;
-        const info = (errorsForRow as any)['item_number'];
-        const currentValue = (data[rowIdx] as any)?.['item_number'];
-        // Only apply uniqueness error when the value is non-empty
-        if (info && currentValue !== undefined && currentValue !== null && String(currentValue) !== '') {
-          existing['item_number'] = [
-            {
-              message: info.message,
-              level: info.level,
-              source: info.source,
-              type: info.type,
-            },
-          ];
-        }
-        // If value is now present, make sure to clear any lingering Required error
-        if (currentValue !== undefined && currentValue !== null && String(currentValue) !== '' && existing['item_number']) {
-          existing['item_number'] = (existing['item_number'] as any[]).filter((e) => e.type !== ErrorType.Required);
-          if ((existing['item_number'] as any[]).length === 0) delete existing['item_number'];
-        }
-        if (Object.keys(existing).length > 0) newMap.set(rowIdx, existing);
-        else newMap.delete(rowIdx);
+    const runValidation = () => {
+      if (cancelled) return;
+
+      const uniqueMap = validateUniqueField(currentData, 'item_number');
+      const rowsWithUnique = new Set<number>();
+      uniqueMap.forEach((_, idx) => rowsWithUnique.add(idx));
+
+      startTransition(() => {
+        setValidationErrors((prev) => {
+          const newMap = new Map(prev);
+
+          uniqueMap.forEach((errorsForRow, rowIdx) => {
+          const existing = { ...(newMap.get(rowIdx) || {}) } as Record<string, any[]>;
+          const info = (errorsForRow as any)['item_number'];
+          const currentValue = (currentData[rowIdx] as any)?.['item_number'];
+
+          if (info && currentValue !== undefined && currentValue !== null && String(currentValue) !== '') {
+            existing['item_number'] = [
+              {
+                message: info.message,
+                level: info.level,
+                source: info.source,
+                type: info.type,
+              },
+            ];
+          }
+
+          if (currentValue !== undefined && currentValue !== null && String(currentValue) !== '' && existing['item_number']) {
+            existing['item_number'] = (existing['item_number'] as any[]).filter((e) => e.type !== ErrorType.Required);
+            if ((existing['item_number'] as any[]).length === 0) delete existing['item_number'];
+          }
+
+          if (Object.keys(existing).length > 0) newMap.set(rowIdx, existing);
+          else newMap.delete(rowIdx);
+        });
+
+        newMap.forEach((rowErrs, rowIdx) => {
+          const currentValue = (currentData[rowIdx] as any)?.['item_number'];
+          const shouldRemoveUnique =
+            !rowsWithUnique.has(rowIdx) ||
+            currentValue === undefined ||
+            currentValue === null ||
+            String(currentValue) === '';
+
+          if (shouldRemoveUnique && (rowErrs as any)['item_number']) {
+            const filtered = (rowErrs as any)['item_number'].filter((e: any) => e.type !== ErrorType.Unique);
+            if (filtered.length > 0) (rowErrs as any)['item_number'] = filtered;
+            else delete (rowErrs as any)['item_number'];
+          }
+
+          if (currentValue !== undefined && currentValue !== null && String(currentValue) !== '' && (rowErrs as any)['item_number']) {
+            const nonRequired = (rowErrs as any)['item_number'].filter((e: any) => e.type !== ErrorType.Required);
+            if (nonRequired.length > 0) (rowErrs as any)['item_number'] = nonRequired;
+            else delete (rowErrs as any)['item_number'];
+          }
+
+          if (Object.keys(rowErrs).length > 0) newMap.set(rowIdx, rowErrs);
+          else newMap.delete(rowIdx);
+        });
+
+          return newMap;
+        });
       });
+    };
 
-      // Remove stale unique errors for rows no longer duplicated
-      newMap.forEach((rowErrs, rowIdx) => {
-        const currentValue = (data[rowIdx] as any)?.['item_number'];
-        const shouldRemoveUnique = !rowsWithUnique.has(rowIdx) || currentValue === undefined || currentValue === null || String(currentValue) === '';
-        if (shouldRemoveUnique && (rowErrs as any)['item_number']) {
-          const filtered = (rowErrs as any)['item_number'].filter((e: any) => e.type !== ErrorType.Unique);
-          if (filtered.length > 0) (rowErrs as any)['item_number'] = filtered;
-          else delete (rowErrs as any)['item_number'];
-        }
-        // If value now present, also clear any lingering Required error for this field
-        if (currentValue !== undefined && currentValue !== null && String(currentValue) !== '' && (rowErrs as any)['item_number']) {
-          const nonRequired = (rowErrs as any)['item_number'].filter((e: any) => e.type !== ErrorType.Required);
-          if (nonRequired.length > 0) (rowErrs as any)['item_number'] = nonRequired;
-          else delete (rowErrs as any)['item_number'];
-        }
+    const schedule = () => {
+      if (typeof window === 'undefined') {
+        runValidation();
+        return;
+      }
 
-        if (Object.keys(rowErrs).length > 0) newMap.set(rowIdx, rowErrs);
-        else newMap.delete(rowIdx);
-      });
+      const win = window as Window & typeof globalThis & {
+        requestIdleCallback?: (callback: IdleRequestCallback, options?: IdleRequestOptions) => number;
+        cancelIdleCallback?: (handle: number) => void;
+      };
 
-      return newMap;
-    });
+      if (win.requestIdleCallback) {
+        const handle = win.requestIdleCallback(() => {
+          pendingItemNumberValidationRef.current = null;
+          if (cancelled) return;
+          runValidation();
+        }, { timeout: 250 });
+
+        pendingItemNumberValidationRef.current = {
+          cancel: () => win.cancelIdleCallback?.(handle),
+        };
+        return;
+      }
+
+      const timeoutId = window.setTimeout(() => {
+        pendingItemNumberValidationRef.current = null;
+        if (cancelled) return;
+        runValidation();
+      }, 16);
+
+      pendingItemNumberValidationRef.current = {
+        cancel: () => window.clearTimeout(timeoutId),
+      };
+    };
+
+    schedule();
+
+    return () => {
+      cancelled = true;
+      pendingItemNumberValidationRef.current?.cancel();
+      pendingItemNumberValidationRef.current = null;
+    };
   }, [data, validateUniqueField, setValidationErrors]);
 
   // Update fields with latest options

inventory/vite.config.ts

@@ -45,49 +45,51 @@ export default defineConfig(({ mode }) => {
       port: 5175,
       proxy: {
         "/api/aircall": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
           rewrite: (path) => path,
         },
         "/api/klaviyo": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
           rewrite: (path) => path,
         },
         "/api/meta": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
           rewrite: (path) => path,
         },
         "/api/gorgias": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
           rewrite: (path) => path,
         },
         "/api/dashboard-analytics": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
-          rewrite: (path) => path.replace("/api/dashboard-analytics", "/api/analytics"),
+          cookieDomainRewrite: {
+            "inventory.kent.pw": "localhost"
+          },
         },
         "/api/typeform": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
           rewrite: (path) => path,
         },
         "/api/acot": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
           rewrite: (path) => path,
         },
         "/api/clarity": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
           rewrite: (path) => path,
@@ -128,7 +130,7 @@ export default defineConfig(({ mode }) => {
           },
         },
         "/dashboard-auth": {
-          target: "https://dashboard.kent.pw",
+          target: "https://inventory.kent.pw",
           changeOrigin: true,
           secure: false,
           ws: true,