performance-optimization-patterns

⚡ Performance Optimization Patterns

🎯 Performance Philosophy for POS Systems

Critical Performance Metrics

• Order Creation: < 500ms from click to confirmation
• Payment Processing: < 2s for complete transaction
• Kitchen Updates: Real-time (< 100ms propagation)
• Product Search: < 200ms for instant results
• Database Queries: < 100ms for typical CRUD operations

Performance Monitoring Strategy

// Performance monitoring utilities
class PerformanceMonitor {
  static timeOperation<T>(name: string, operation: () => Promise<T>): Promise<T> {
    console.time(name);
    return operation().finally(() => console.timeEnd(name));
  }

  static measureRender(componentName: string) {
    return (Component: React.ComponentType<any>) => {
      return React.memo(Component, (prevProps, nextProps) => {
        const start = performance.now();
        const shouldUpdate = !Object.is(prevProps, nextProps);
        const end = performance.now();
        
        if (end - start > 1) {
          console.warn(`${componentName} render check took ${end - start}ms`);
        }
        
        return !shouldUpdate;
      });
    };
  }
}

🗄️ Database Performance Patterns

Optimized Query Patterns

// ✅ CORRECT: Efficient query with proper indexing
func (h *OrderHandler) GetOrdersWithPagination(c *gin.Context) {
    page := getIntParam(c, "page", 1)
    perPage := getIntParam(c, "per_page", 20)
    status := c.Query("status")
    
    // Use indexed columns in WHERE clause
    query := `
        SELECT 
            o.id, o.order_number, o.status, o.total_amount, o.created_at,
            u.username, t.table_number,
            COUNT(*) OVER() as total_count
        FROM orders o
        LEFT JOIN users u ON o.user_id = u.id
        LEFT JOIN dining_tables t ON o.table_id = t.id
        WHERE ($1 = '' OR o.status = $1)
            AND o.created_at >= CURRENT_DATE - INTERVAL '7 days'
        ORDER BY o.created_at DESC
        LIMIT $2 OFFSET $3
    `
    
    offset := (page - 1) * perPage
    rows, err := h.db.Query(query, status, perPage, offset)
    // ... handle results
}

// ✅ CORRECT: Batch insert for order items
func (h *OrderHandler) CreateOrderWithItems(c *gin.Context) {
    tx, err := h.db.Begin()
    if err != nil {
        // handle error
        return
    }
    defer tx.Rollback()

    // Create order
    var orderID string
    err = tx.QueryRow(`
        INSERT INTO orders (customer_name, order_type, status, total_amount)
        VALUES ($1, $2, $3, $4)
        RETURNING id
    `, req.CustomerName, req.OrderType, "pending", req.TotalAmount).Scan(&orderID)

    // Batch insert order items (much faster than individual inserts)
    if len(req.Items) > 0 {
        valueStrings := make([]string, 0, len(req.Items))
        valueArgs := make([]interface{}, 0, len(req.Items)*4)
        
        for i, item := range req.Items {
            valueStrings = append(valueStrings, fmt.Sprintf("($%d, $%d, $%d, $%d)", 
                i*4+1, i*4+2, i*4+3, i*4+4))
            valueArgs = append(valueArgs, orderID, item.ProductID, item.Quantity, item.Price)
        }

        stmt := fmt.Sprintf(`
            INSERT INTO order_items (order_id, product_id, quantity, price)
            VALUES %s
        `, strings.Join(valueStrings, ","))

        _, err = tx.Exec(stmt, valueArgs...)
        if err != nil {
            return // Rollback automatically called
        }
    }

    err = tx.Commit()
    // ... handle success
}