Optimize validation table

.gitignore

@@ -50,6 +50,11 @@ dashboard-server/meta-server/._package-lock.json
 dashboard-server/meta-server/._services
 *.tsbuildinfo
 
+uploads/*
+uploads/**/*
+**/uploads/*
+**/uploads/**/*
+
 # CSV data files
 *.csv
 csv/*

docs/ValidationStep-Refactoring-Plan.md

@@ -0,0 +1,396 @@
+# ValidationStep Component Refactoring Plan
+
+## Overview
+
+This document outlines a comprehensive plan to refactor the current ValidationStep component (4000+ lines) into a more maintainable, modular structure. The new implementation will be developed alongside the existing component without modifying the original code. Once completed, the previous step in the workflow will offer the option to continue to either the original ValidationStep or the new implementation.
+
+## Table of Contents
+
+1. [Current Component Analysis](#current-component-analysis)
+2. [New Architecture Design](#new-architecture-design)
+3. [Component Structure](#component-structure)
+4. [State Management](#state-management)
+5. [Key Features Implementation](#key-features-implementation)
+6. [Integration Plan](#integration-plan)
+7. [Testing Strategy](#testing-strategy)
+8. [Project Timeline](#project-timeline)
+9. [Design Principles](#design-principles)
+10. [Appendix: Function Reference](#appendix-function-reference)
+
+## Current Component Analysis
+
+The current ValidationStep component has several issues:
+
+- **Size**: At over 4000 lines, it's difficult to maintain and understand
+- **Multiple responsibilities**: Handles validation, UI rendering, template management, and more
+- **Special cases**: Contains numerous special case handlers and exceptions
+- **Complex state management**: State is distributed across multiple useState calls
+- **Tightly coupled concerns**: UI, validation logic, and business rules are intertwined
+
+### Key Features to Preserve
+
+1. **Data Validation**
+   - Field-level validation (required, regex, unique)
+   - Row-level validation (supplier, company fields)
+   - UPC validation with API integration
+   - AI-assisted validation
+
+2. **Template Management**
+   - Saving, loading, and applying templates
+   - Template-based validation
+
+3. **UI Components**
+   - Editable table with specialized cell renderers
+   - Error display and management
+   - Filtering and sorting capabilities
+   - Status indicators and progress tracking
+
+4. **Special Field Handling**
+   - Input fields with price formatting
+   - Multi-input fields with separator configuration
+   - Select fields with dropdown options
+   - Checkbox fields with boolean value mapping
+   - UPC fields with specialized validation
+
+5. **User Interaction Flows**
+   - Tab and keyboard navigation
+   - Bulk operations (select all, apply template)
+   - Row validation on value change
+   - Error reporting and display
+
+## New Architecture Design
+
+The new architecture will follow these principles:
+
+1. **Separation of Concerns**
+   - UI rendering separate from business logic
+   - Validation logic isolated from state management
+   - Clear interfaces between components
+
+2. **Composable Components**
+   - Small, focused components with single responsibilities
+   - Reusable pattern for different field types
+
+3. **Centralized State Management**
+   - Custom hooks for state management
+   - Clear data flow patterns
+   - Reduced prop drilling
+
+4. **Consistent Error Handling**
+   - Standardized error structure
+   - Predictable error propagation
+   - User-friendly error display
+
+5. **Performance Optimization**
+   - Virtualized table rendering
+   - Memoization of expensive computations
+   - Deferred validation for better user experience
+
+## Component Structure
+
+The new ValidationStepNew folder has the following structure:
+
+```
+ValidationStepNew/
+├── index.tsx                    # Main entry point that composes all pieces
+├── components/                  # UI Components
+│   ├── ValidationContainer.tsx  # Main wrapper component
+│   ├── ValidationTable.tsx      # Table implementation
+│   ├── ValidationCell.tsx       # Cell component
+│   ├── ValidationSidebar.tsx    # Sidebar with controls
+│   ├── ValidationToolbar.tsx    # Top toolbar (removed as unnecessary)
+│   ├── TemplateManager.tsx      # Template management
+│   ├── FilterPanel.tsx          # Filtering interface (integrated into Container)
+│   └── cells/                   # Specialized cell renderers
+│       ├── InputCell.tsx
+│       ├── SelectCell.tsx
+│       ├── MultiInputCell.tsx
+│       └── CheckboxCell.tsx
+├── hooks/                       # Custom hooks
+│   ├── useValidationState.tsx   # Main state management
+│   ├── useTemplates.tsx         # Template-related logic (integrated into ValidationState)
+│   ├── useFilters.tsx           # Filtering logic (integrated into ValidationState)
+│   └── useUpcValidation.tsx     # UPC-specific validation
+└── utils/                       # Utility functions
+    ├── validationUtils.ts       # Validation helper functions
+    ├── formatters.ts            # Value formatting utilities 
+    └── constants.ts             # Constant values and configuration
+```
+
+### Component Responsibilities
+
+#### ValidationContainer
+- Main container component
+- Coordinates between subcomponents
+- Manages global state
+- Handles navigation events (next, back)
+- Contains filter controls
+
+#### ValidationTable
+- Displays the data in tabular form
+- Manages selection state
+- Handles keyboard navigation
+- Integrates with TanStack Table
+- Displays properly styled rows and cells
+
+#### ValidationCell
+- Factory component that renders appropriate cell type
+- Manages cell-level state
+- Handles validation errors display
+- Manages edit mode
+- Shows consistent error indicators
+
+#### TemplateManager
+- Handles template selection UI
+- Provides template save/load functionality
+- Manages template application to rows
+
+#### Cell Components
+- **InputCell**: Handles text input with multiline and price support
+- **MultiInputCell**: Handles multiple values with separator configuration
+- **SelectCell**: Command/popover component for single selection
+- **CheckboxCell**: Boolean value selection with mapping support
+
+## State Management
+
+### Core State Interface
+
+```typescript
+interface ValidationState<T extends string> {
+  // Core data
+  data: RowData<T>[];
+  filteredData: RowData<T>[];
+  
+  // Validation state
+  isValidating: boolean;
+  validationErrors: Map<number, Record<string, Error[]>>;
+  rowValidationStatus: Map<number, 'pending' | 'validating' | 'validated' | 'error'>;
+  
+  // Selection state
+  rowSelection: RowSelectionState;
+  
+  // Template state
+  templates: Template[];
+  selectedTemplateId: string | null;
+  
+  // Filter state
+  filters: FilterState;
+  
+  // Methods
+  updateRow: (rowIndex: number, key: T, value: any) => void;
+  validateRow: (rowIndex: number) => Promise<void>;
+  validateUpc: (rowIndex: number, upcValue: string) => Promise<void>;
+  applyTemplate: (templateId: string, rowIndexes: number[]) => void;
+  saveTemplate: (name: string, type: string) => void;
+  setFilters: (newFilters: Partial<FilterState>) => void;
+  // Additional methods...
+}
+```
+
+### useValidationState Hook
+
+The main state management hook handles:
+
+- Data manipulation (update, sort, filter)
+- Selection management
+- Validation coordination
+- Integration with validation utilities
+- Template management
+- Filtering and sorting
+
+## Key Features Implementation
+
+### 1. Field Type Handling
+
+Implemented a strategy pattern for different field types:
+
+```typescript
+// In ValidationCell
+const renderCellContent = () => {
+  const fieldType = field.fieldType.type
+  
+  switch (fieldType) {
+    case 'input':
+      return <InputCell<T> field={field} value={value} onChange={onChange} ... />
+    case 'multi-input':
+      return <MultiInputCell<T> field={field} value={value} onChange={onChange} ... />
+    case 'select':
+      return <SelectCell<T> field={field} value={value} onChange={onChange} ... />
+    // etc.
+  }
+}
+```
+
+### 2. Validation Logic
+
+Validation is broken down into clear steps:
+
+1. **Field Validation**: Apply field-level validations (required, regex, etc.)
+2. **Row Validation**: Apply row-level validations and rowHook
+3. **Table Validation**: Apply table-level validations (unique) and tableHook
+
+Validation now happens automatically without explicit buttons, with immediate feedback on field blur.
+
+### 3. UI Components
+
+UI components follow these principles:
+
+1. **Consistent Styling**: All components use shadcn UI for consistent look and feel
+2. **Visual Feedback**: Errors are clearly indicated with icons and border styling
+3. **Intuitive Editing**: Fields show outlines even when not in focus, and edit on click
+4. **Proper Command Pattern**: Select and multi-select fields use command/popover pattern for better UX
+5. **Focus Management**: Fields close when clicking away and perform validation on blur
+
+## Design Principles
+
+Based on user preferences and best practices, the following design principles guide this refactoring:
+
+1. **Automatic Validation**
+   - Validation should happen automatically without explicit buttons
+   - All validation should run on initial data load
+   - Fields should validate on blur (when user clicks away)
+
+2. **Modern UI Patterns**
+   - Command/popover components for all selects and multi-selects
+   - Consistent field outlines and borders even when not in focus
+   - Badge patterns for multi-select items
+   - Clear visual indicators for errors
+
+3. **Reduced Complexity**
+   - Remove unnecessary UI elements like "validate all" buttons
+   - Eliminate redundant state and toast notifications
+   - Simplify component hierarchy where possible
+   - Find root causes rather than adding special cases
+
+4. **Consistent Component Behavior**
+   - Fields should close when clicking away
+   - All inputs should follow the same editing pattern
+   - Error handling should be consistent across all field types
+   - Multi-select fields should allow selecting multiple items with clear visual feedback
+
+## Integration Plan
+
+### 1. Creating the New Component Structure
+
+Folder structure has been created without modifying the existing code:
+
+```bash
+mkdir -p inventory/src/lib/react-spreadsheet-import/src/steps/ValidationStepNew/{components,hooks,utils}
+mkdir -p inventory/src/lib/react-spreadsheet-import/src/steps/ValidationStepNew/components/cells
+```
+
+### 2. Implementing Basic Components
+
+Core components have been implemented:
+
+1. Created index.tsx as the main entry point
+2. Implemented ValidationContainer with basic state management
+3. Created ValidationTable for data display
+4. Implemented basic cell rendering with specialized cell types
+
+### 3. Implementing State Management
+
+State management has been implemented:
+
+1. Created useValidationState hook
+2. Implemented data transformation utilities
+3. Added validation logic
+
+### 4. Integrating with Previous Step
+
+The previous step component allows choosing between validation implementations, enabling gradual testing and adoption.
+
+## Testing Strategy
+
+1. **Unit Tests**
+   - Test individual utility functions
+   - Test hooks in isolation
+   - Test individual UI components
+
+2. **Integration Tests**
+   - Test component interactions
+   - Test state management flow
+   - Test validation logic integration
+
+3. **Comparison Tests**
+   - Compare output of new component with original
+   - Verify that all functionality works the same
+
+4. **Performance Tests**
+   - Measure render times
+   - Evaluate memory usage
+   - Compare against original component
+
+## Project Timeline
+
+1. **Phase 1: Initial Structure (Completed)**
+   - Set up folder structure
+   - Implement basic components
+   - Create core state management
+
+2. **Phase 2: Core Functionality (In Progress)**
+   - Implement validation logic (completed)
+   - Create cell renderers (completed)
+   - Add template management (in progress)
+
+3. **Phase 3: Special Features (Upcoming)**
+   - Implement UPC validation
+   - Add AI validation
+   - Handle special cases
+
+4. **Phase 4: UI Refinement (Ongoing)**
+   - Improve error display (completed)
+   - Enhance user interactions (completed)
+   - Optimize performance (in progress)
+
+5. **Phase 5: Testing and Integration (Upcoming)**
+   - Write tests
+   - Fix bugs
+   - Integrate with previous step
+
+## Appendix: Function Reference
+
+This section documents the core functions from the original ValidationStep that need to be preserved in the new implementation.
+
+### Validation Functions
+
+1. **validateRegex** - Validates values against regex patterns
+2. **getValidationError** - Determines field-level validation errors
+3. **validateAndCommit** - Validates and commits new values
+4. **validateData** - Validates all data rows
+5. **validateUpcAndGenerateItemNumbers** - Validates UPC codes and generates item numbers
+
+### Formatting Functions
+
+1. **formatPrice** - Formats price values
+2. **getDisplayValue** - Gets formatted display value based on field type
+3. **isMultiInputType** - Checks if field is multi-input type
+4. **getMultiInputSeparator** - Gets separator for multi-input fields
+5. **isPriceField** - Checks if field should be formatted as price
+
+### Template Functions
+
+1. **loadTemplates** - Loads templates from storage
+2. **saveTemplate** - Saves a new template
+3. **applyTemplate** - Applies a template to selected rows
+4. **getTemplateDisplayText** - Gets display text for a template
+
+### AI Validation Functions
+
+1. **handleAiValidation** - Triggers AI validation
+2. **showCurrentPrompt** - Shows current AI prompt
+3. **getFieldDisplayValue** - Gets display value for a field
+4. **highlightDifferences** - Highlights differences between original and corrected values
+5. **getFieldDisplayValueWithHighlight** - Gets display value with highlighted differences
+6. **revertAiChange** - Reverts an AI-suggested change
+7. **isChangeReverted** - Checks if an AI change has been reverted
+
+### Event Handlers
+
+1. **handleUpcValueUpdate** - Handles UPC value updates
+2. **handleBlur** - Handles input blur events
+3. **handleWheel** - Handles wheel events for navigation
+4. **copyValueDown** - Copies a value to cells below
+5. **handleSkuGeneration** - Generates SKUs
+
+By following this refactoring plan, we continue to transform the monolithic ValidationStep component into a modular, maintainable set of components while preserving all existing functionality and aligning with user preferences for design and behavior. 

docs/ValidationStepNew-Implementation-Status.md

@@ -0,0 +1,137 @@
+# ValidationStepNew Implementation Status
+
+## Overview
+
+This document outlines the current status of the ValidationStepNew implementation, a refactored version of the original ValidationStep component. The goal is to create a more maintainable, modular component that preserves all functionality of the original while eliminating technical debt and implementing modern UI patterns.
+
+## Design Principles
+
+Based on the user's preferences, we're following these core design principles:
+
+1. **Automatic Validation**
+   - ✅ Validation runs automatically on data load
+   - ✅ No explicit "validate all" button needed
+   - ✅ Fields validate on blur when user clicks away
+   - ✅ Immediate visual feedback for validation errors
+
+2. **Modern UI Patterns**
+   - ✅ Command/popover components for selects and multi-selects
+   - ✅ Consistent field outlines and borders even when not in focus
+   - ✅ Badge pattern for multi-select field items
+   - ✅ Visual indicators for errors with appropriate styling
+
+3. **Reduced Complexity**
+   - ✅ Removed unnecessary UI elements like "validate all" button
+   - ✅ Eliminated redundant toast notifications
+   - ✅ Simplified component hierarchy
+   - ✅ Fixed root causes rather than adding special cases
+
+4. **Consistent Behavior**
+   - ✅ Fields close when clicking away
+   - ✅ All inputs follow the same editing pattern
+   - ✅ Error handling is consistent across field types
+   - ✅ Multi-select fields allow selecting multiple items
+
+## Completed Components
+
+### Core Structure
+- ✅ Main component structure
+- ✅ Directory organization
+- ✅ TypeScript interfaces
+- ✅ Props definition and passing
+
+### State Management
+- ✅ `useValidationState` hook for centralized state
+- ✅ Data validation logic
+- ✅ Integration with rowHook and tableHook
+- ✅ Error tracking and management
+- ✅ Row selection
+- ✅ Automatic validation on data load
+
+### UI Components
+- ✅ ValidationContainer with appropriate layout
+- ✅ ValidationTable with shadcn UI components
+- ✅ ValidationCell factory component
+- ✅ Row select/deselect functionality
+- ✅ Error display and indicators
+- ✅ Selection action bar
+
+### Cell Components
+- ✅ InputCell with price and multiline support
+- ✅ MultiInputCell with separator configuration
+- ✅ SelectCell using command/popover pattern
+- ✅ CheckboxCell with boolean mapping
+- ✅ Consistent styling across all field types
+- ✅ Proper edit/view state management
+- ✅ Outlined borders in both edit and view modes
+
+### Utility Functions
+- ✅ Value formatting for display
+- ✅ Field type detection
+- ✅ Error creation and management
+- ✅ Price formatting
+
+### UI Improvements
+- ✅ Consistent borders and field outlines
+- ✅ Fields that properly close when clicking away
+- ✅ Multi-select with badge UI pattern
+- ✅ Command pattern for searchable select menus
+- ✅ Better visual error indication
+
+## Pending Tasks
+
+### Enhanced Validation
+- ⏳ AI validation system
+- ⏳ Custom validation hooks
+- ⏳ Enhanced UPC validation with API integration
+- ⏳ Validation visualizations
+
+### Advanced UI Features
+- ⏳ Table virtualization for performance
+- ⏳ Drag-and-drop reordering
+- ⏳ Bulk operations (copy down, fill all, etc.)
+- ⏳ Keyboard navigation improvements
+- ⏳ Template dialogs and management UI
+
+### Special Features
+- ⏳ Image preview integration
+- ⏳ SKU generation system
+- ⏳ Item number generation
+- ⏳ Dependent dropdown values
+
+### Testing
+- ⏳ Unit tests for utility functions
+- ⏳ Component tests
+- ⏳ Integration tests
+- ⏳ Performance benchmarks
+
+## Known Issues
+
+1. TypeScript error for `validationDisabled` property in ValidationCell.tsx
+2. Some type casting is needed due to complex generic types
+3. Need to address edge cases for multi-select fields validation
+4. Proper error handling for API calls needs implementation
+
+## Next Steps
+
+1. Fix TypeScript errors in ValidationCell and related components
+2. Complete template management functionality
+3. Implement UPC validation with API integration
+4. Make multi-select field validation more robust
+5. Add comprehensive tests
+
+## Performance Improvements
+
+We've already implemented several performance optimizations:
+
+1. ✅ More efficient state updates by removing unnecessary re-renders
+2. ✅ Better error handling to prevent cascading validations
+3. ✅ Improved component isolation to prevent unnecessary re-renders
+4. ✅ Automatic validation that doesn't block the UI
+
+Additional planned improvements:
+
+1. Virtualized table rendering for large datasets
+2. Memoization of expensive calculations 
+3. Optimized state updates to minimize re-renders
+4. Batched API calls for validation 

docs/fix-multi-select.md

@@ -0,0 +1,72 @@
+# Solution: Keeping Dropdowns Open During Multiple Selections
+
+## The Problem
+
+When implementing a multi-select dropdown in React, a common issue occurs:
+
+1. You select an item in the dropdown
+2. The `onChange` handler is called, updating the data
+3. This triggers a re-render of the parent component (in this case, the entire table)
+4. During the re-render, the dropdown is unmounted and remounted
+5. This causes the dropdown to close before you can make multiple selections
+
+## The Solution: Deferred State Updates
+
+The key insight is to **separate local state management from parent state updates**:
+
+```typescript
+// Step 1: Add local state to track selections 
+const [internalValue, setInternalValue] = useState<string[]>(value)
+
+// Step 2: Handle popover open state changes
+const handleOpenChange = useCallback((newOpen: boolean) => {
+  if (open && !newOpen) {
+    // Only update parent state when dropdown closes
+    if (JSON.stringify(internalValue) !== JSON.stringify(value)) {
+      onChange(internalValue);
+    }
+  }
+  
+  setOpen(newOpen);
+  
+  if (newOpen) {
+    // Sync internal state with external state when opening
+    setInternalValue(value);
+  }
+}, [open, internalValue, value, onChange]);
+
+// Step 3: Toggle selection only updates internal state
+const toggleSelection = useCallback((selectedValue: string) => {
+  setInternalValue(prev => {
+    if (prev.includes(selectedValue)) {
+      return prev.filter(v => v !== selectedValue);
+    } else {
+      return [...prev, selectedValue];
+    }
+  });
+}, []);
+```
+
+## Why This Works
+
+1. **No parent re-renders during selection**: Since we're only updating local state, the parent component doesn't re-render during selection.
+2. **Consistent UI**: The dropdown shows accurate selected states using the internal value.
+3. **Data integrity**: The final selections are properly synchronized back to the parent when done.
+4. **Resilient to external changes**: Initial state is synchronized when opening the dropdown.
+
+## Implementation Steps
+
+1. Create a local state variable to track selections inside the component
+2. Only make selections against this local state while the dropdown is open
+3. Defer updating the parent until the dropdown is explicitly closed
+4. When opening, synchronize the internal state with the external value
+
+## Benefits
+
+This pattern:
+- Avoids re-render cycles that would unmount the dropdown
+- Maintains UI consistency during multi-selection
+- Simplifies the component's interaction with parent components
+- Works with existing component lifecycles rather than fighting against them
+
+This solution is much simpler than trying to prevent event propagation or manipulating DOM events, and addresses the root cause of the issue: premature re-rendering.

docs/validation-table-scroll-issue.md

@@ -0,0 +1,538 @@
+# ValidationTable Scroll Position Issue
+
+## Problem Description
+
+The `ValidationTable` component in the inventory application suffers from a persistent scroll position issue. When the table content updates or re-renders, the scroll position resets to the top left corner. This creates a poor user experience, especially when users are working with large datasets and need to maintain their position while making edits or filtering data.
+
+Specific behaviors:
+- Scroll position resets to the top left corner during re-renders
+- User loses their place in the table when data is updated
+- The table does not preserve vertical or horizontal scroll position
+
+## Relevant Files
+
+- **`inventory/src/lib/react-spreadsheet-import/src/steps/ValidationStepNew/components/ValidationTable.tsx`**
+  - Main component that renders the validation table
+  - Handles scroll position management
+  
+- **`inventory/src/lib/react-spreadsheet-import/src/steps/ValidationStepNew/components/ValidationContainer.tsx`**
+  - Parent component that wraps ValidationTable 
+  - Creates an EnhancedValidationTable wrapper component
+  - Manages data and state for the validation table
+
+- **`inventory/src/lib/react-spreadsheet-import/src/steps/ValidationStepNew/hooks/useValidationState.tsx`**
+  - Provides state management and data manipulation functions
+  - Contains scroll-related code in the `updateRow` function
+  
+- **`inventory/src/lib/react-spreadsheet-import/src/steps/ValidationStepNew/components/ValidationCell.tsx`**
+  - Renders individual cells in the table
+  - May influence re-renders that affect scroll position
+
+## Failed Attempts
+
+We've tried multiple approaches to fix the scroll position issue, none of which have been successful:
+
+### 1. Using Refs for Scroll Position
+
+```typescript
+const scrollPosition = useRef({
+  left: 0,
+  top: 0
+});
+
+// Capture position on scroll
+const handleScroll = useCallback(() => {
+  if (tableContainerRef.current) {
+    scrollPosition.current = {
+      left: tableContainerRef.current.scrollLeft,
+      top: tableContainerRef.current.scrollTop
+    };
+  }
+}, []);
+
+// Restore in useLayoutEffect
+useLayoutEffect(() => {
+  const container = tableContainerRef.current;
+  if (container) {
+    const { left, top } = scrollPosition.current;
+    if (left || top) {
+      container.scrollLeft = left;
+      container.scrollTop = top;
+    }
+  }
+});
+```
+
+Result: Scroll position was still lost during updates.
+
+### 2. Multiple Restoration Attempts with Timeouts
+
+```typescript
+// Multiple timeouts at different intervals
+setTimeout(() => {
+  if (tableContainerRef.current) {
+    tableContainerRef.current.scrollTop = savedPosition.top;
+    tableContainerRef.current.scrollLeft = savedPosition.left;
+  }
+}, 0);
+
+setTimeout(() => {
+  if (tableContainerRef.current) {
+    tableContainerRef.current.scrollTop = savedPosition.top;
+    tableContainerRef.current.scrollLeft = savedPosition.left;
+  }
+}, 50);
+
+// Additional timeouts at 100ms, 300ms
+```
+
+Result: Still not reliable, scroll position would reset between timeouts or after all timeouts completed.
+
+### 3. Using MutationObserver and ResizeObserver
+
+```typescript
+// Create a mutation observer to detect DOM changes
+const mutationObserver = new MutationObserver(() => {
+  if (shouldPreserveScroll) {
+    restoreScrollPosition();
+  }
+});
+
+// Start observing the table for DOM changes
+mutationObserver.observe(scrollableContainer, { 
+  childList: true, 
+  subtree: true,
+  attributes: true,
+  attributeFilter: ['style', 'class']
+});
+
+// Create a resize observer
+const resizeObserver = new ResizeObserver(() => {
+  if (shouldPreserveScroll) {
+    restoreScrollPosition();
+  }
+});
+
+// Observe the table container
+resizeObserver.observe(scrollableContainer);
+```
+
+Result: Did not reliably maintain scroll position, and sometimes caused other rendering issues.
+
+### 4. Recursive Restoration Approach
+
+```typescript
+let attempts = 0;
+const maxAttempts = 5;
+
+const restore = () => {
+  if (tableContainerRef.current) {
+    tableContainerRef.current.scrollTop = y;
+    tableContainerRef.current.scrollLeft = x;
+    
+    attempts++;
+    if (attempts < maxAttempts) {
+      setTimeout(restore, 50 * attempts);
+    }
+  }
+};
+
+restore();
+```
+
+Result: No improvement, scroll position still reset.
+
+### 5. Using React State for Scroll Position
+
+```typescript
+const [scrollPos, setScrollPos] = useState<{top: number; left: number}>({top: 0, left: 0});
+
+// Track the scroll event
+useEffect(() => {
+  const handleScroll = () => {
+    if (scrollContainerRef.current) {
+      setScrollPos({
+        top: scrollContainerRef.current.scrollTop,
+        left: scrollContainerRef.current.scrollLeft
+      });
+    }
+  };
+  
+  // Add scroll listener...
+}, []);
+
+// Restore scroll position
+useLayoutEffect(() => {
+  const container = scrollContainerRef.current;
+  const { top, left } = scrollPos;
+  
+  if (top > 0 || left > 0) {
+    requestAnimationFrame(() => {
+      if (container) {
+        container.scrollTop = top;
+        container.scrollLeft = left;
+      }
+    });
+  }
+}, [scrollPos, data]);
+```
+
+Result: Caused the screen to shake violently when scrolling and did not preserve position.
+
+### 6. Using Key Attribute for Stability
+
+```typescript
+return (
+  <div 
+    key="validation-table-container"
+    ref={scrollContainerRef}
+    className="overflow-auto max-h-[calc(100vh-300px)]"
+  >
+    {/* Table content */}
+  </div>
+);
+```
+
+Result: Did not resolve the issue and may have contributed to rendering instability.
+
+### 7. Removing Scroll Management from Other Components
+
+We removed scroll position management code from:
+- `useValidationState.tsx` (in the updateRow function)
+- `ValidationContainer.tsx` (in the enhancedUpdateRow function)
+
+Result: This did not fix the issue either.
+
+### 8. Simple Scroll Position Management with Event Listeners
+
+```typescript
+// Create a ref to store scroll position
+const scrollPosition = useRef({ left: 0, top: 0 });
+const tableContainerRef = useRef<HTMLDivElement>(null);
+
+// Save scroll position when scrolling
+const handleScroll = useCallback(() => {
+  if (tableContainerRef.current) {
+    scrollPosition.current = {
+      left: tableContainerRef.current.scrollLeft,
+      top: tableContainerRef.current.scrollTop
+    };
+  }
+}, []);
+
+// Add scroll listener
+useEffect(() => {
+  const container = tableContainerRef.current;
+  if (container) {
+    container.addEventListener('scroll', handleScroll);
+    return () => container.removeEventListener('scroll', handleScroll);
+  }
+}, [handleScroll]);
+
+// Restore scroll position after data changes
+useLayoutEffect(() => {
+  const container = tableContainerRef.current;
+  if (container) {
+    const { left, top } = scrollPosition.current;
+    if (left > 0 || top > 0) {
+      container.scrollLeft = left;
+      container.scrollTop = top;
+    }
+  }
+}, [data]);
+```
+
+Result: Still did not maintain scroll position during updates.
+
+### 9. Memoized Scroll Container Component
+
+```typescript
+// Create a stable scroll container that won't re-render with the table
+const ScrollContainer = React.memo(({ children }: { children: React.ReactNode }) => {
+  const containerRef = useRef<HTMLDivElement>(null);
+  const scrollPosition = useRef({ left: 0, top: 0 });
+
+  const handleScroll = useCallback(() => {
+    if (containerRef.current) {
+      scrollPosition.current = {
+        left: containerRef.current.scrollLeft,
+        top: containerRef.current.scrollTop
+      };
+    }
+  }, []);
+
+  useEffect(() => {
+    const container = containerRef.current;
+    if (container) {
+      // Set initial scroll position if it exists
+      if (scrollPosition.current.left > 0 || scrollPosition.current.top > 0) {
+        container.scrollLeft = scrollPosition.current.left;
+        container.scrollTop = scrollPosition.current.top;
+      }
+      container.addEventListener('scroll', handleScroll);
+      return () => container.removeEventListener('scroll', handleScroll);
+    }
+  }, [handleScroll]);
+
+  return (
+    <div ref={containerRef} className="overflow-auto max-h-[calc(100vh-300px)]">
+      {children}
+    </div>
+  );
+});
+```
+
+Result: Still did not maintain scroll position during updates, even with a memoized container.
+
+### 10. Using TanStack Table State Management
+
+```typescript
+// Track scroll state in the table instance
+const [scrollState, setScrollState] = useState({ scrollLeft: 0, scrollTop: 0 });
+
+const table = useReactTable({
+  data,
+  columns,
+  getCoreRowModel: getCoreRowModel(),
+  state: { 
+    rowSelection,
+    // Include scroll position in table state
+    scrollLeft: scrollState.scrollLeft,
+    scrollTop: scrollState.scrollTop
+  },
+  onStateChange: (updater) => {
+    if (typeof updater === 'function') {
+      const newState = updater({
+        rowSelection,
+        scrollLeft: scrollState.scrollLeft,
+        scrollTop: scrollState.scrollTop
+      });
+      if ('scrollLeft' in newState || 'scrollTop' in newState) {
+        setScrollState({
+          scrollLeft: newState.scrollLeft ?? scrollState.scrollLeft,
+          scrollTop: newState.scrollTop ?? scrollState.scrollTop
+        });
+      }
+    }
+  }
+});
+
+// Handle scroll events
+const handleScroll = useCallback((event: React.UIEvent<HTMLDivElement>) => {
+  const target = event.target as HTMLDivElement;
+  setScrollState({
+    scrollLeft: target.scrollLeft,
+    scrollTop: target.scrollTop
+  });
+}, []);
+
+// Restore scroll position after updates
+useLayoutEffect(() => {
+  if (tableContainerRef.current) {
+    tableContainerRef.current.scrollLeft = scrollState.scrollLeft;
+    tableContainerRef.current.scrollTop = scrollState.scrollTop;
+  }
+}, [data, scrollState]);
+```
+
+Result: Still did not maintain scroll position during updates, even with table state management.
+
+### 11. Using CSS Sticky Positioning
+
+```typescript
+return (
+  <div className="relative max-h-[calc(100vh-300px)] overflow-auto">
+    <Table>
+      <TableHeader className="sticky top-0 z-10 bg-background">
+        <TableRow>
+          {table.getFlatHeaders().map((header) => (
+            <TableHead 
+              key={header.id}
+              style={{ 
+                width: `${header.getSize()}px`,
+                minWidth: `${header.getSize()}px`,
+                position: 'sticky',
+                top: 0,
+                backgroundColor: 'inherit'
+              }}
+            >
+              {/* Header content */}
+            </TableHead>
+          ))}
+        </TableRow>
+      </TableHeader>
+      <TableBody>
+        {/* Table body content */}
+      </TableBody>
+    </Table>
+  </div>
+);
+```
+
+Result: Still did not maintain scroll position during updates, even with native CSS scrolling.
+
+### 12. Optimized Memoization with Object.is
+
+```typescript
+// Memoize data structures to prevent unnecessary re-renders
+const memoizedData = useMemo(() => data, [data]);
+const memoizedValidationErrors = useMemo(() => validationErrors, [validationErrors]);
+const memoizedValidatingCells = useMemo(() => validatingCells, [validatingCells]);
+const memoizedItemNumbers = useMemo(() => itemNumbers, [itemNumbers]);
+
+// Use Object.is for more efficient comparisons
+export default React.memo(ValidationTable, (prev, next) => {
+  if (!Object.is(prev.data.length, next.data.length)) return false;
+  
+  if (prev.validationErrors.size !== next.validationErrors.size) return false;
+  for (const [key, value] of prev.validationErrors) {
+    if (!next.validationErrors.has(key)) return false;
+    if (!Object.is(value, next.validationErrors.get(key))) return false;
+  }
+  
+  // ... more optimized comparisons ...
+});
+```
+
+Result: Caused the page to crash with "TypeError: undefined has no properties" in the MemoizedCell component.
+
+### 13. Simplified Component Structure
+
+```typescript
+const ValidationTable = <T extends string>({
+  data,
+  fields,
+  rowSelection,
+  setRowSelection,
+  updateRow,
+  validationErrors,
+  // ... other props
+}) => {
+  const tableContainerRef = useRef<HTMLDivElement>(null);
+  const lastScrollPosition = useRef({ left: 0, top: 0 });
+
+  // Simple scroll position management
+  const handleScroll = useCallback(() => {
+    if (tableContainerRef.current) {
+      lastScrollPosition.current = {
+        left: tableContainerRef.current.scrollLeft,
+        top: tableContainerRef.current.scrollTop
+      };
+    }
+  }, []);
+
+  useEffect(() => {
+    const container = tableContainerRef.current;
+    if (container) {
+      container.addEventListener('scroll', handleScroll);
+      return () => container.removeEventListener('scroll', handleScroll);
+    }
+  }, [handleScroll]);
+
+  useLayoutEffect(() => {
+    const container = tableContainerRef.current;
+    if (container) {
+      const { left, top } = lastScrollPosition.current;
+      if (left > 0 || top > 0) {
+        requestAnimationFrame(() => {
+          if (container) {
+            container.scrollLeft = left;
+            container.scrollTop = top;
+          }
+        });
+      }
+    }
+  }, [data]);
+
+  return (
+    <div ref={tableContainerRef} className="overflow-auto max-h-[calc(100vh-300px)]">
+      <Table>
+        {/* ... table content ... */}
+        <TableBody>
+          {table.getRowModel().rows.map((row) => (
+            <TableRow
+              key={row.id}
+              className={cn(
+                "hover:bg-muted/50",
+                row.getIsSelected() ? "bg-muted/50" : "",
+                validationErrors.get(data.indexOf(row.original)) ? "bg-red-50/40" : ""
+              )}
+            >
+              {/* ... row content ... */}
+            </TableRow>
+          ))}
+        </TableBody>
+      </Table>
+    </div>
+  );
+};
+```
+
+Result: Still did not maintain scroll position during updates. However, this implementation restored the subtle red highlight on rows with validation errors, which is a useful visual indicator that should be preserved in future attempts.
+
+### 14. Portal-Based Scroll Container
+
+```typescript
+// Create a stable container outside of React's control
+const createStableContainer = () => {
+  const containerId = 'validation-table-container';
+  let container = document.getElementById(containerId);
+  
+  if (!container) {
+    container = document.createElement('div');
+    container.id = containerId;
+    container.className = 'overflow-auto';
+    container.style.maxHeight = 'calc(100vh - 300px)';
+    document.body.appendChild(container);
+  }
+  
+  return container;
+};
+
+const ValidationTable = <T extends string>({...props}) => {
+  const [container] = useState(createStableContainer);
+  const [mounted, setMounted] = useState(false);
+
+  useEffect(() => {
+    setMounted(true);
+    return () => {
+      if (container && container.parentNode) {
+        container.parentNode.removeChild(container);
+      }
+    };
+  }, [container]);
+
+  // ... table configuration ...
+
+  return createPortal(content, container);
+};
+```
+
+Result: The table contents failed to render at all. The portal-based approach to maintain scroll position by moving the scroll container outside of React's control was unsuccessful.
+
+## Current Understanding
+
+The scroll position issue appears to be complex and likely stems from multiple factors:
+
+1. React's virtual DOM reconciliation may be replacing the scroll container element during updates
+2. The table uses complex memo patterns with custom equality checks that may not be working as expected
+3. The data structure may be changing in ways that cause complete re-renders
+4. The component hierarchy (with EnhancedValidationTable wrapper) may be affecting DOM stability
+
+## Next Steps to Consider
+
+At this point, we have tried multiple approaches without success:
+1. Various scroll position management techniques
+2. Memoization and optimization strategies
+3. Different component structures
+4. Portal-based rendering
+
+Given that none of these approaches have fully resolved the issue, it may be worth:
+1. Investigating if there are any parent component updates forcing re-renders
+2. Profiling the application to identify the exact timing of scroll position resets
+3. Considering if the current table implementation could be simplified
+4. Exploring if the data update patterns could be optimized to reduce re-renders
+
+## Conclusion
+
+The scroll position issue has proven resistant to multiple solution attempts. Each approach has either failed to maintain scroll position, introduced new issues, or in some cases (like the portal-based approach) prevented the table from rendering entirely. A deeper investigation into the component lifecycle and data flow may be necessary to identify the root cause. 

ecosystem.config.js

@@ -1,5 +1,209 @@
+// 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',
@@ -7,16 +211,12 @@ module.exports = {
       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',
-      env_production: {
-        NODE_ENV: 'production',
-        AUTH_PORT: 3011,
-        JWT_SECRET: process.env.JWT_SECRET
-      }
+      log_file: 'inventory-server/auth/logs/pm2/combined.log'
     }
   ]
-}; 
+};

inventory-server/auth/add-user.js

@@ -0,0 +1,103 @@
+require('dotenv').config({ path: '../.env' });
+const bcrypt = require('bcrypt');
+const { Pool } = require('pg');
+const inquirer = require('inquirer');
+
+// Log connection details for debugging (remove in production)
+console.log('Attempting to connect with:', {
+  host: process.env.DB_HOST,
+  user: process.env.DB_USER,
+  database: process.env.DB_NAME,
+  port: process.env.DB_PORT
+});
+
+const pool = new Pool({
+  host: process.env.DB_HOST,
+  user: process.env.DB_USER,
+  password: process.env.DB_PASSWORD,
+  database: process.env.DB_NAME,
+  port: process.env.DB_PORT,
+});
+
+async function promptUser() {
+  const questions = [
+    {
+      type: 'input',
+      name: 'username',
+      message: 'Enter username:',
+      validate: (input) => {
+        if (input.length < 3) {
+          return 'Username must be at least 3 characters long';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'password',
+      name: 'password',
+      message: 'Enter password:',
+      mask: '*',
+      validate: (input) => {
+        if (input.length < 8) {
+          return 'Password must be at least 8 characters long';
+        }
+        return true;
+      }
+    },
+    {
+      type: 'password',
+      name: 'confirmPassword',
+      message: 'Confirm password:',
+      mask: '*',
+      validate: (input, answers) => {
+        if (input !== answers.password) {
+          return 'Passwords do not match';
+        }
+        return true;
+      }
+    }
+  ];
+
+  return inquirer.prompt(questions);
+}
+
+async function addUser() {
+  try {
+    // Get user input
+    const answers = await promptUser();
+    const { username, password } = answers;
+
+    // Hash password
+    const saltRounds = 10;
+    const hashedPassword = await bcrypt.hash(password, saltRounds);
+
+    // Check if user already exists
+    const checkResult = await pool.query(
+      'SELECT id FROM users WHERE username = $1',
+      [username]
+    );
+
+    if (checkResult.rows.length > 0) {
+      console.error('Error: Username already exists');
+      process.exit(1);
+    }
+
+    // Insert new user
+    const result = await pool.query(
+      'INSERT INTO users (username, password) VALUES ($1, $2) RETURNING id',
+      [username, hashedPassword]
+    );
+
+    console.log(`User ${username} created successfully with id ${result.rows[0].id}`);
+  } catch (error) {
+    console.error('Error creating user:', error);
+    console.error('Error details:', error.message);
+    if (error.code) {
+      console.error('Error code:', error.code);
+    }
+  } finally {
+    await pool.end();
+  }
+}
+
+addUser(); 

inventory-server/auth/add_user.js

@@ -1,41 +0,0 @@
-const bcrypt = require('bcrypt');
-const mysql = require('mysql2/promise');
-const readline = require('readline').createInterface({
-  input: process.stdin,
-  output: process.stdout,
-});
-require('dotenv').config({ path: '../.env' });
-
-const dbConfig = {
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-};
-
-async function addUser() {
-  const username = await askQuestion('Enter username: ');
-  const password = await askQuestion('Enter password: ');
-
-  const hashedPassword = await bcrypt.hash(password, 10);
-
-  const connection = await mysql.createConnection(dbConfig);
-
-  try {
-    await connection.query('INSERT INTO users (username, password) VALUES (?, ?)', [username, hashedPassword]);
-    console.log(`User ${username} added successfully.`);
-  } catch (error) {
-    console.error('Error adding user:', error);
-  } finally {
-    connection.end();
-    readline.close();
-  }
-}
-
-function askQuestion(query) {
-  return new Promise(resolve => readline.question(query, ans => {
-    resolve(ans);
-  }));
-}
-
-addUser(); 

inventory-server/auth/package.json

@@ -1,21 +1,19 @@
 {
-  "name": "auth-server",
+  "name": "inventory-auth-server",
   "version": "1.0.0",
-  "description": "Authentication server for inventory management",
+  "description": "Authentication server for inventory management system",
   "main": "server.js",
   "scripts": {
-    "start": "node server.js",
-    "dev": "nodemon server.js",
-    "add_user": "node add_user.js"
+    "start": "node server.js"
   },
   "dependencies": {
     "bcrypt": "^5.1.1",
     "cors": "^2.8.5",
-    "dotenv": "^16.4.5",
+    "dotenv": "^16.4.7",
     "express": "^4.18.2",
-    "jsonwebtoken": "^9.0.2"
-  },
-  "devDependencies": {
-    "nodemon": "^3.1.0"
+    "inquirer": "^8.2.6",
+    "jsonwebtoken": "^9.0.2",
+    "morgan": "^1.10.0",
+    "pg": "^8.11.3"
   }
-} 
+}

inventory-server/auth/schema.sql

@@ -1,6 +1,6 @@
-CREATE TABLE `users` (
-  `id` INT AUTO_INCREMENT PRIMARY KEY,
-  `username` VARCHAR(255) NOT NULL UNIQUE,
-  `password` VARCHAR(255) NOT NULL,
-  `created_at` TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+CREATE TABLE users (
+  id SERIAL PRIMARY KEY,
+  username VARCHAR(255) NOT NULL UNIQUE,
+  password VARCHAR(255) NOT NULL,
+  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
 ); 

inventory-server/auth/server.js

@@ -1,135 +1,102 @@
+require('dotenv').config({ path: '../.env' });
 const express = require('express');
+const cors = require('cors');
 const bcrypt = require('bcrypt');
 const jwt = require('jsonwebtoken');
-const cors = require('cors');
-const mysql = require('mysql2/promise');
-require('dotenv').config({ path: '../.env' });
+const { Pool } = require('pg');
+const morgan = require('morgan');
+
+// Log startup configuration
+console.log('Starting auth server with config:', {
+  host: process.env.DB_HOST,
+  user: process.env.DB_USER,
+  database: process.env.DB_NAME,
+  port: process.env.DB_PORT,
+  auth_port: process.env.AUTH_PORT
+});
 
 const app = express();
-const PORT = process.env.AUTH_PORT || 3011;
+const port = process.env.AUTH_PORT || 3011;
 
 // Database configuration
-const dbConfig = {
+const pool = new Pool({
   host: process.env.DB_HOST,
   user: process.env.DB_USER,
   password: process.env.DB_PASSWORD,
   database: process.env.DB_NAME,
-};
+  port: process.env.DB_PORT,
+});
 
-// Create a connection pool
-const pool = mysql.createPool(dbConfig);
-
-app.use(cors({
-  origin: [
-    'https://inventory.kent.pw',
-    'http://localhost:5173',
-    'http://127.0.0.1:5173',
-    /^http:\/\/192\.168\.\d+\.\d+(:\d+)?$/,
-    /^http:\/\/10\.\d+\.\d+\.\d+(:\d+)?$/
-  ],
-  methods: ['GET', 'POST', 'OPTIONS'],
-  allowedHeaders: ['Content-Type', 'Authorization', 'X-Requested-With'],
-  credentials: true,
-  exposedHeaders: ['set-cookie']
-}));
+// Middleware
 app.use(express.json());
-
-// Debug middleware to log request details
-app.use((req, res, next) => {
-  console.log('Request details:', {
-    method: req.method,
-    url: req.url,
-    origin: req.get('Origin'),
-    headers: req.headers,
-    body: req.body,
-  });
-  next();
-});
-
-// Registration endpoint
-app.post('/register', async (req, res) => {
-  try {
-    const { username, password } = req.body;
-    const hashedPassword = await bcrypt.hash(password, 10);
-
-    const connection = await pool.getConnection();
-    await connection.query('INSERT INTO users (username, password) VALUES (?, ?)', [username, hashedPassword]);
-    connection.release();
-
-    res.status(201).json({ message: 'User registered successfully' });
-  } catch (error) {
-    console.error('Registration error:', error);
-    res.status(500).json({ error: 'Registration failed' });
-  }
-});
+app.use(morgan('combined'));
+app.use(cors({
+  origin: ['http://localhost:5173', 'https://inventory.kent.pw'],
+  credentials: true
+}));
 
 // Login endpoint
 app.post('/login', async (req, res) => {
+  const { username, password } = req.body;
+
   try {
-    const { username, password } = req.body;
-    console.log(`Login attempt for user: ${username}`);
-
-    const connection = await pool.getConnection();
-    const [rows] = await connection.query(
-      'SELECT * FROM users WHERE username = ?',
-      [username],
+    // Get user from database
+    const result = await pool.query(
+      'SELECT id, username, password FROM users WHERE username = $1',
+      [username]
     );
-    connection.release();
 
-    if (rows.length === 1) {
-      const user = rows[0];
-      const passwordMatch = await bcrypt.compare(password, user.password);
+    const user = result.rows[0];
 
-      if (passwordMatch) {
-        console.log(`User ${username} authenticated successfully`);
-        const token = jwt.sign(
-          { username: user.username },
-          process.env.JWT_SECRET,
-          { expiresIn: '1h' },
-        );
-        res.json({ token });
-      } else {
-        console.error(`Invalid password for user: ${username}`);
-        res.status(401).json({ error: 'Invalid credentials' });
-      }
-    } else {
-      console.error(`User not found: ${username}`);
-      res.status(401).json({ error: 'Invalid credentials' });
+    // Check if user exists and password is correct
+    if (!user || !(await bcrypt.compare(password, user.password))) {
+      return res.status(401).json({ error: 'Invalid username or password' });
     }
+
+    // Generate JWT token
+    const token = jwt.sign(
+      { userId: user.id, username: user.username },
+      process.env.JWT_SECRET,
+      { expiresIn: '24h' }
+    );
+
+    res.json({ token });
   } catch (error) {
     console.error('Login error:', error);
-    res.status(500).json({ error: 'Login failed' });
+    res.status(500).json({ error: 'Internal server error' });
   }
 });
 
-// Protected endpoint example
+// Protected route to verify token
 app.get('/protected', async (req, res) => {
   const authHeader = req.headers.authorization;
+
   if (!authHeader) {
-    return res.status(401).json({ error: 'Unauthorized' });
+    return res.status(401).json({ error: 'No token provided' });
   }
 
-  const token = authHeader.split(' ')[1];
   try {
+    const token = authHeader.split(' ')[1];
     const decoded = jwt.verify(token, process.env.JWT_SECRET);
-
-    // Optionally, you can fetch the user from the database here
-    // to verify that the user still exists or to get more user information
-    const connection = await pool.getConnection();
-    const [rows] = await connection.query('SELECT * FROM users WHERE username = ?', [decoded.username]);
-    connection.release();
-
-    if (rows.length === 0) {
-      return res.status(401).json({ error: 'User not found' });
-    }
-
-    res.json({ message: 'Protected resource accessed', user: decoded });
+    res.json({ userId: decoded.userId, username: decoded.username });
   } catch (error) {
-    console.error('Protected endpoint error:', error);
-    res.status(403).json({ error: 'Invalid token' });
+    console.error('Token verification error:', error);
+    res.status(401).json({ error: 'Invalid token' });
   }
 });
 
-app.listen(PORT, "0.0.0.0", () => {
-  console.log(`Auth server running on port ${PORT}`);
-}); 
+// Health check endpoint
+app.get('/health', (req, res) => {
+  res.json({ status: 'healthy' });
+});
+
+// Error handling middleware
+app.use((err, req, res, next) => {
+  console.error(err.stack);
+  res.status(500).json({ error: 'Something broke!' });
+});
+
+// Start server
+app.listen(port, () => {
+  console.log(`Auth server running on port ${port}`);
+});

inventory-server/db/config-schema.sql

@@ -1,150 +1,207 @@
 -- Configuration tables schema
 
+-- Create function for updating timestamps if it doesn't exist
+CREATE OR REPLACE FUNCTION update_updated_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- Create function for updating updated_at timestamps
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
 -- Stock threshold configurations
-CREATE TABLE IF NOT EXISTS stock_thresholds (
-    id INT NOT NULL,
+CREATE TABLE stock_thresholds (
+    id INTEGER NOT NULL,
     category_id BIGINT,  -- NULL means default/global threshold
     vendor VARCHAR(100), -- NULL means applies to all vendors
-    critical_days INT NOT NULL DEFAULT 7,
-    reorder_days INT NOT NULL DEFAULT 14,
-    overstock_days INT NOT NULL DEFAULT 90,
-    low_stock_threshold INT NOT NULL DEFAULT 5,
-    min_reorder_quantity INT NOT NULL DEFAULT 1,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    critical_days INTEGER NOT NULL DEFAULT 7,
+    reorder_days INTEGER NOT NULL DEFAULT 14,
+    overstock_days INTEGER NOT NULL DEFAULT 90,
+    low_stock_threshold INTEGER NOT NULL DEFAULT 5,
+    min_reorder_quantity INTEGER NOT NULL DEFAULT 1,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (id),
     FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    UNIQUE KEY unique_category_vendor (category_id, vendor),
-    INDEX idx_st_metrics (category_id, vendor)
+    UNIQUE (category_id, vendor)
 );
 
+CREATE TRIGGER update_stock_thresholds_updated
+    BEFORE UPDATE ON stock_thresholds
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE INDEX idx_st_metrics ON stock_thresholds(category_id, vendor);
+
 -- Lead time threshold configurations
-CREATE TABLE IF NOT EXISTS lead_time_thresholds (
-    id INT NOT NULL,
+CREATE TABLE lead_time_thresholds (
+    id INTEGER NOT NULL,
     category_id BIGINT,  -- NULL means default/global threshold
     vendor VARCHAR(100), -- NULL means applies to all vendors
-    target_days INT NOT NULL DEFAULT 14,
-    warning_days INT NOT NULL DEFAULT 21,
-    critical_days INT NOT NULL DEFAULT 30,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    target_days INTEGER NOT NULL DEFAULT 14,
+    warning_days INTEGER NOT NULL DEFAULT 21,
+    critical_days INTEGER NOT NULL DEFAULT 30,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (id),
     FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    UNIQUE KEY unique_category_vendor (category_id, vendor)
+    UNIQUE (category_id, vendor)
 );
 
+CREATE TRIGGER update_lead_time_thresholds_updated
+    BEFORE UPDATE ON lead_time_thresholds
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
 -- Sales velocity window configurations
-CREATE TABLE IF NOT EXISTS sales_velocity_config (
-    id INT NOT NULL,
+CREATE TABLE sales_velocity_config (
+    id INTEGER NOT NULL,
     category_id BIGINT,  -- NULL means default/global threshold
     vendor VARCHAR(100), -- NULL means applies to all vendors
-    daily_window_days INT NOT NULL DEFAULT 30,
-    weekly_window_days INT NOT NULL DEFAULT 7,
-    monthly_window_days INT NOT NULL DEFAULT 90,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    daily_window_days INTEGER NOT NULL DEFAULT 30,
+    weekly_window_days INTEGER NOT NULL DEFAULT 7,
+    monthly_window_days INTEGER NOT NULL DEFAULT 90,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (id),
     FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    UNIQUE KEY unique_category_vendor (category_id, vendor),
-    INDEX idx_sv_metrics (category_id, vendor)
+    UNIQUE (category_id, vendor)
 );
 
+CREATE TRIGGER update_sales_velocity_config_updated
+    BEFORE UPDATE ON sales_velocity_config
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE INDEX idx_sv_metrics ON sales_velocity_config(category_id, vendor);
+
 -- ABC Classification configurations
-CREATE TABLE IF NOT EXISTS abc_classification_config (
-    id INT NOT NULL PRIMARY KEY,
+CREATE TABLE abc_classification_config (
+    id INTEGER NOT NULL PRIMARY KEY,
     a_threshold DECIMAL(5,2) NOT NULL DEFAULT 20.0,
     b_threshold DECIMAL(5,2) NOT NULL DEFAULT 50.0,
-    classification_period_days INT NOT NULL DEFAULT 90,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP
+    classification_period_days INTEGER NOT NULL DEFAULT 90,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
 );
 
+CREATE TRIGGER update_abc_classification_config_updated
+    BEFORE UPDATE ON abc_classification_config
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
 -- Safety stock configurations
-CREATE TABLE IF NOT EXISTS safety_stock_config (
-    id INT NOT NULL,
+CREATE TABLE safety_stock_config (
+    id INTEGER NOT NULL,
     category_id BIGINT,  -- NULL means default/global threshold
     vendor VARCHAR(100), -- NULL means applies to all vendors
-    coverage_days INT NOT NULL DEFAULT 14,
+    coverage_days INTEGER NOT NULL DEFAULT 14,
     service_level DECIMAL(5,2) NOT NULL DEFAULT 95.0,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (id),
     FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    UNIQUE KEY unique_category_vendor (category_id, vendor),
-    INDEX idx_ss_metrics (category_id, vendor)
+    UNIQUE (category_id, vendor)
 );
 
+CREATE TRIGGER update_safety_stock_config_updated
+    BEFORE UPDATE ON safety_stock_config
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+CREATE INDEX idx_ss_metrics ON safety_stock_config(category_id, vendor);
+
 -- Turnover rate configurations
-CREATE TABLE IF NOT EXISTS turnover_config (
-    id INT NOT NULL,
+CREATE TABLE turnover_config (
+    id INTEGER NOT NULL,
     category_id BIGINT,  -- NULL means default/global threshold
     vendor VARCHAR(100), -- NULL means applies to all vendors
-    calculation_period_days INT NOT NULL DEFAULT 30,
+    calculation_period_days INTEGER NOT NULL DEFAULT 30,
     target_rate DECIMAL(10,2) NOT NULL DEFAULT 1.0,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (id),
     FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    UNIQUE KEY unique_category_vendor (category_id, vendor)
+    UNIQUE (category_id, vendor)
 );
 
+CREATE TRIGGER update_turnover_config_updated
+    BEFORE UPDATE ON turnover_config
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
 -- Create table for sales seasonality factors
-CREATE TABLE IF NOT EXISTS sales_seasonality (
-    month INT NOT NULL,
+CREATE TABLE sales_seasonality (
+    month INTEGER NOT NULL,
     seasonality_factor DECIMAL(5,3) DEFAULT 0,
-    last_updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    last_updated TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (month),
-    CHECK (month BETWEEN 1 AND 12),
-    CHECK (seasonality_factor BETWEEN -1.0 AND 1.0)
+    CONSTRAINT month_range CHECK (month BETWEEN 1 AND 12),
+    CONSTRAINT seasonality_range CHECK (seasonality_factor BETWEEN -1.0 AND 1.0)
 );
 
--- Insert default global thresholds if not exists
+CREATE TRIGGER update_sales_seasonality_updated
+    BEFORE UPDATE ON sales_seasonality
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column();
+
+-- Insert default global thresholds
 INSERT INTO stock_thresholds (id, category_id, vendor, critical_days, reorder_days, overstock_days)
 VALUES (1, NULL, NULL, 7, 14, 90)
-ON DUPLICATE KEY UPDATE
-    critical_days = VALUES(critical_days),
-    reorder_days = VALUES(reorder_days),
-    overstock_days = VALUES(overstock_days);
+ON CONFLICT (id) DO UPDATE SET
+    critical_days = EXCLUDED.critical_days,
+    reorder_days = EXCLUDED.reorder_days,
+    overstock_days = EXCLUDED.overstock_days;
 
 INSERT INTO lead_time_thresholds (id, category_id, vendor, target_days, warning_days, critical_days)
 VALUES (1, NULL, NULL, 14, 21, 30)
-ON DUPLICATE KEY UPDATE
-    target_days = VALUES(target_days),
-    warning_days = VALUES(warning_days),
-    critical_days = VALUES(critical_days);
+ON CONFLICT (id) DO UPDATE SET
+    target_days = EXCLUDED.target_days,
+    warning_days = EXCLUDED.warning_days,
+    critical_days = EXCLUDED.critical_days;
 
 INSERT INTO sales_velocity_config (id, category_id, vendor, daily_window_days, weekly_window_days, monthly_window_days)
 VALUES (1, NULL, NULL, 30, 7, 90)
-ON DUPLICATE KEY UPDATE
-    daily_window_days = VALUES(daily_window_days),
-    weekly_window_days = VALUES(weekly_window_days),
-    monthly_window_days = VALUES(monthly_window_days);
+ON CONFLICT (id) DO UPDATE SET
+    daily_window_days = EXCLUDED.daily_window_days,
+    weekly_window_days = EXCLUDED.weekly_window_days,
+    monthly_window_days = EXCLUDED.monthly_window_days;
 
 INSERT INTO abc_classification_config (id, a_threshold, b_threshold, classification_period_days)
 VALUES (1, 20.0, 50.0, 90)
-ON DUPLICATE KEY UPDATE
-    a_threshold = VALUES(a_threshold),
-    b_threshold = VALUES(b_threshold),
-    classification_period_days = VALUES(classification_period_days);
+ON CONFLICT (id) DO UPDATE SET
+    a_threshold = EXCLUDED.a_threshold,
+    b_threshold = EXCLUDED.b_threshold,
+    classification_period_days = EXCLUDED.classification_period_days;
 
 INSERT INTO safety_stock_config (id, category_id, vendor, coverage_days, service_level)
 VALUES (1, NULL, NULL, 14, 95.0)
-ON DUPLICATE KEY UPDATE
-    coverage_days = VALUES(coverage_days),
-    service_level = VALUES(service_level);
+ON CONFLICT (id) DO UPDATE SET
+    coverage_days = EXCLUDED.coverage_days,
+    service_level = EXCLUDED.service_level;
 
 INSERT INTO turnover_config (id, category_id, vendor, calculation_period_days, target_rate)
 VALUES (1, NULL, NULL, 30, 1.0)
-ON DUPLICATE KEY UPDATE
-    calculation_period_days = VALUES(calculation_period_days),
-    target_rate = VALUES(target_rate);
+ON CONFLICT (id) DO UPDATE SET
+    calculation_period_days = EXCLUDED.calculation_period_days,
+    target_rate = EXCLUDED.target_rate;
 
 -- Insert default seasonality factors (neutral)
 INSERT INTO sales_seasonality (month, seasonality_factor)
 VALUES 
     (1, 0), (2, 0), (3, 0), (4, 0), (5, 0), (6, 0),
     (7, 0), (8, 0), (9, 0), (10, 0), (11, 0), (12, 0)
-ON DUPLICATE KEY UPDATE last_updated = CURRENT_TIMESTAMP;
+ON CONFLICT (month) DO UPDATE SET
+    last_updated = CURRENT_TIMESTAMP;
 
 -- View to show thresholds with category names
 CREATE OR REPLACE VIEW stock_thresholds_view AS
@@ -153,9 +210,9 @@ SELECT
     c.name as category_name,
     CASE 
         WHEN st.category_id IS NULL AND st.vendor IS NULL THEN 'Global Default'
-        WHEN st.category_id IS NULL THEN CONCAT('Vendor: ', st.vendor)
-        WHEN st.vendor IS NULL THEN CONCAT('Category: ', c.name)
-        ELSE CONCAT('Category: ', c.name, ' / Vendor: ', st.vendor)
+        WHEN st.category_id IS NULL THEN 'Vendor: ' || st.vendor
+        WHEN st.vendor IS NULL THEN 'Category: ' || c.name
+        ELSE 'Category: ' || c.name || ' / Vendor: ' || st.vendor
     END as threshold_scope
 FROM 
     stock_thresholds st
@@ -171,59 +228,51 @@ ORDER BY
     c.name,
     st.vendor;
 
+-- History and status tables
 CREATE TABLE IF NOT EXISTS calculate_history (
-    id BIGINT AUTO_INCREMENT PRIMARY KEY,
-    start_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    end_time TIMESTAMP NULL,
-    duration_seconds INT,
-    duration_minutes DECIMAL(10,2) GENERATED ALWAYS AS (duration_seconds / 60.0) STORED,
-    total_products INT DEFAULT 0,
-    total_orders INT DEFAULT 0,
-    total_purchase_orders INT DEFAULT 0,
-    processed_products INT DEFAULT 0,
-    processed_orders INT DEFAULT 0,
-    processed_purchase_orders INT DEFAULT 0,
-    status ENUM('running', 'completed', 'failed', 'cancelled') DEFAULT 'running',
+    id BIGSERIAL PRIMARY KEY,
+    start_time TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    end_time TIMESTAMP WITH TIME ZONE NULL,
+    duration_seconds INTEGER,
+    duration_minutes DECIMAL(10,2) GENERATED ALWAYS AS (duration_seconds::decimal / 60.0) STORED,
+    total_products INTEGER DEFAULT 0,
+    total_orders INTEGER DEFAULT 0,
+    total_purchase_orders INTEGER DEFAULT 0,
+    processed_products INTEGER DEFAULT 0,
+    processed_orders INTEGER DEFAULT 0,
+    processed_purchase_orders INTEGER DEFAULT 0,
+    status calculation_status DEFAULT 'running',
     error_message TEXT,
-    additional_info JSON,
-    INDEX idx_status_time (status, start_time)
+    additional_info JSONB
 );
 
 CREATE TABLE IF NOT EXISTS calculate_status (
-    module_name ENUM(
-        'product_metrics',
-        'time_aggregates',
-        'financial_metrics',
-        'vendor_metrics',
-        'category_metrics',
-        'brand_metrics',
-        'sales_forecasts',
-        'abc_classification'
-    ) PRIMARY KEY,
-    last_calculation_timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    INDEX idx_last_calc (last_calculation_timestamp)
+    module_name module_name PRIMARY KEY,
+    last_calculation_timestamp TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP
 );
 
 CREATE TABLE IF NOT EXISTS sync_status (
     table_name VARCHAR(50) PRIMARY KEY,
-    last_sync_timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    last_sync_id BIGINT,
-    INDEX idx_last_sync (last_sync_timestamp)
+    last_sync_timestamp TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    last_sync_id BIGINT
 );
 
 CREATE TABLE IF NOT EXISTS import_history (
-    id BIGINT AUTO_INCREMENT PRIMARY KEY,
+    id BIGSERIAL PRIMARY KEY,
     table_name VARCHAR(50) NOT NULL,
-    start_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    end_time TIMESTAMP NULL,
-    duration_seconds INT,
-    duration_minutes DECIMAL(10,2) GENERATED ALWAYS AS (duration_seconds / 60.0) STORED,
-    records_added INT DEFAULT 0,
-    records_updated INT DEFAULT 0,
+    start_time TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    end_time TIMESTAMP WITH TIME ZONE NULL,
+    duration_seconds INTEGER,
+    duration_minutes DECIMAL(10,2) GENERATED ALWAYS AS (duration_seconds::decimal / 60.0) STORED,
+    records_added INTEGER DEFAULT 0,
+    records_updated INTEGER DEFAULT 0,
     is_incremental BOOLEAN DEFAULT FALSE,
-    status ENUM('running', 'completed', 'failed', 'cancelled') DEFAULT 'running',
+    status calculation_status DEFAULT 'running',
     error_message TEXT,
-    additional_info JSON,
-    INDEX idx_table_time (table_name, start_time),
-    INDEX idx_status (status)
-); 
+    additional_info JSONB
+);
+
+-- Create all indexes after tables are fully created
+CREATE INDEX IF NOT EXISTS idx_last_calc ON calculate_status(last_calculation_timestamp);
+CREATE INDEX IF NOT EXISTS idx_last_sync ON sync_status(last_sync_timestamp);
+CREATE INDEX IF NOT EXISTS idx_table_time ON import_history(table_name, start_time); 

inventory-server/db/metrics-schema.sql

@@ -1,8 +1,8 @@
 -- Disable foreign key checks
-SET FOREIGN_KEY_CHECKS = 0;
+SET session_replication_role = 'replica';
 
 -- Temporary tables for batch metrics processing
-CREATE TABLE IF NOT EXISTS temp_sales_metrics (
+CREATE TABLE temp_sales_metrics (
     pid BIGINT NOT NULL,
     daily_sales_avg DECIMAL(10,3),
     weekly_sales_avg DECIMAL(10,3),
@@ -14,9 +14,9 @@ CREATE TABLE IF NOT EXISTS temp_sales_metrics (
     PRIMARY KEY (pid)
 );
 
-CREATE TABLE IF NOT EXISTS temp_purchase_metrics (
+CREATE TABLE temp_purchase_metrics (
     pid BIGINT NOT NULL,
-    avg_lead_time_days INT,
+    avg_lead_time_days INTEGER,
     last_purchase_date DATE,
     first_received_date DATE,
     last_received_date DATE,
@@ -24,7 +24,7 @@ CREATE TABLE IF NOT EXISTS temp_purchase_metrics (
 );
 
 -- New table for product metrics
-CREATE TABLE IF NOT EXISTS product_metrics (
+CREATE TABLE product_metrics (
     pid BIGINT NOT NULL,
     last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     -- Sales velocity metrics
@@ -32,16 +32,16 @@ CREATE TABLE IF NOT EXISTS product_metrics (
     weekly_sales_avg DECIMAL(10,3),
     monthly_sales_avg DECIMAL(10,3),
     avg_quantity_per_order DECIMAL(10,3),
-    number_of_orders INT,
+    number_of_orders INTEGER,
     first_sale_date DATE,
     last_sale_date DATE,
     -- Stock metrics
-    days_of_inventory INT,
-    weeks_of_inventory INT,
-    reorder_point INT,
-    safety_stock INT,
-    reorder_qty INT DEFAULT 0,
-    overstocked_amt INT DEFAULT 0,
+    days_of_inventory INTEGER,
+    weeks_of_inventory INTEGER,
+    reorder_point INTEGER,
+    safety_stock INTEGER,
+    reorder_qty INTEGER DEFAULT 0,
+    overstocked_amt INTEGER DEFAULT 0,
     -- Financial metrics
     avg_margin_percent DECIMAL(10,3),
     total_revenue DECIMAL(10,3),
@@ -50,7 +50,7 @@ CREATE TABLE IF NOT EXISTS product_metrics (
     gross_profit DECIMAL(10,3),
     gmroi DECIMAL(10,3),
     -- Purchase metrics
-    avg_lead_time_days INT,
+    avg_lead_time_days INTEGER,
     last_purchase_date DATE,
     first_received_date DATE,
     last_received_date DATE,
@@ -60,48 +60,50 @@ CREATE TABLE IF NOT EXISTS product_metrics (
     -- Turnover metrics
     turnover_rate DECIMAL(12,3),
     -- Lead time metrics
-    current_lead_time INT,
-    target_lead_time INT,
+    current_lead_time INTEGER,
+    target_lead_time INTEGER,
     lead_time_status VARCHAR(20),
     -- Forecast metrics
     forecast_accuracy DECIMAL(5,2) DEFAULT NULL,
     forecast_bias DECIMAL(5,2) DEFAULT NULL,
     last_forecast_date DATE DEFAULT NULL,
     PRIMARY KEY (pid),
-    FOREIGN KEY (pid) REFERENCES products(pid) ON DELETE CASCADE,
-    INDEX idx_metrics_revenue (total_revenue),
-    INDEX idx_metrics_stock_status (stock_status),
-    INDEX idx_metrics_lead_time (lead_time_status),
-    INDEX idx_metrics_turnover (turnover_rate),
-    INDEX idx_metrics_last_calculated (last_calculated_at),
-    INDEX idx_metrics_abc (abc_class),
-    INDEX idx_metrics_sales (daily_sales_avg, weekly_sales_avg, monthly_sales_avg),
-    INDEX idx_metrics_forecast (forecast_accuracy, forecast_bias)
+    FOREIGN KEY (pid) REFERENCES products(pid) ON DELETE CASCADE
 );
 
+CREATE INDEX idx_metrics_revenue ON product_metrics(total_revenue);
+CREATE INDEX idx_metrics_stock_status ON product_metrics(stock_status);
+CREATE INDEX idx_metrics_lead_time ON product_metrics(lead_time_status);
+CREATE INDEX idx_metrics_turnover ON product_metrics(turnover_rate);
+CREATE INDEX idx_metrics_last_calculated ON product_metrics(last_calculated_at);
+CREATE INDEX idx_metrics_abc ON product_metrics(abc_class);
+CREATE INDEX idx_metrics_sales ON product_metrics(daily_sales_avg, weekly_sales_avg, monthly_sales_avg);
+CREATE INDEX idx_metrics_forecast ON product_metrics(forecast_accuracy, forecast_bias);
+
 -- New table for time-based aggregates
-CREATE TABLE IF NOT EXISTS product_time_aggregates (
+CREATE TABLE product_time_aggregates (
     pid BIGINT NOT NULL,
-    year INT NOT NULL,
-    month INT NOT NULL,
+    year INTEGER NOT NULL,
+    month INTEGER NOT NULL,
     -- Sales metrics
-    total_quantity_sold INT DEFAULT 0,
+    total_quantity_sold INTEGER DEFAULT 0,
     total_revenue DECIMAL(10,3) DEFAULT 0,
     total_cost DECIMAL(10,3) DEFAULT 0,
-    order_count INT DEFAULT 0,
+    order_count INTEGER DEFAULT 0,
     -- Stock changes
-    stock_received INT DEFAULT 0,
-    stock_ordered INT DEFAULT 0,
+    stock_received INTEGER DEFAULT 0,
+    stock_ordered INTEGER DEFAULT 0,
     -- Calculated fields
     avg_price DECIMAL(10,3),
     profit_margin DECIMAL(10,3),
     inventory_value DECIMAL(10,3),
     gmroi DECIMAL(10,3),
     PRIMARY KEY (pid, year, month),
-    FOREIGN KEY (pid) REFERENCES products(pid) ON DELETE CASCADE,
-    INDEX idx_date (year, month)
+    FOREIGN KEY (pid) REFERENCES products(pid) ON DELETE CASCADE
 );
 
+CREATE INDEX idx_date ON product_time_aggregates(year, month);
+
 -- Create vendor_details table
 CREATE TABLE vendor_details (
     vendor VARCHAR(100) PRIMARY KEY,
@@ -110,45 +112,47 @@ CREATE TABLE vendor_details (
     phone VARCHAR(50),
     status VARCHAR(20) DEFAULT 'active',
     created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-    INDEX idx_status (status)
-) ENGINE=InnoDB;
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX idx_vendor_details_status ON vendor_details(status);
 
 -- New table for vendor metrics
-CREATE TABLE IF NOT EXISTS vendor_metrics (
+CREATE TABLE vendor_metrics (
     vendor VARCHAR(100) NOT NULL,
     last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     -- Performance metrics
     avg_lead_time_days DECIMAL(10,3),
     on_time_delivery_rate DECIMAL(5,2),
     order_fill_rate DECIMAL(5,2),
-    total_orders INT DEFAULT 0,
-    total_late_orders INT DEFAULT 0,
+    total_orders INTEGER DEFAULT 0,
+    total_late_orders INTEGER DEFAULT 0,
     total_purchase_value DECIMAL(10,3) DEFAULT 0,
     avg_order_value DECIMAL(10,3),
     -- Product metrics
-    active_products INT DEFAULT 0,
-    total_products INT DEFAULT 0,
+    active_products INTEGER DEFAULT 0,
+    total_products INTEGER DEFAULT 0,
     -- Financial metrics
     total_revenue DECIMAL(10,3) DEFAULT 0,
     avg_margin_percent DECIMAL(5,2),
     -- Status
     status VARCHAR(20) DEFAULT 'active',
     PRIMARY KEY (vendor),
-    FOREIGN KEY (vendor) REFERENCES vendor_details(vendor) ON DELETE CASCADE,
-    INDEX idx_vendor_performance (on_time_delivery_rate),
-    INDEX idx_vendor_status (status),
-    INDEX idx_metrics_last_calculated (last_calculated_at),
-    INDEX idx_vendor_metrics_orders (total_orders, total_late_orders)
+    FOREIGN KEY (vendor) REFERENCES vendor_details(vendor) ON DELETE CASCADE
 );
 
+CREATE INDEX idx_vendor_performance ON vendor_metrics(on_time_delivery_rate);
+CREATE INDEX idx_vendor_status ON vendor_metrics(status);
+CREATE INDEX idx_vendor_metrics_last_calculated ON vendor_metrics(last_calculated_at);
+CREATE INDEX idx_vendor_metrics_orders ON vendor_metrics(total_orders, total_late_orders);
+
 -- New table for category metrics
-CREATE TABLE IF NOT EXISTS category_metrics (
+CREATE TABLE category_metrics (
     category_id BIGINT NOT NULL,
     last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     -- Product metrics
-    product_count INT DEFAULT 0,
-    active_products INT DEFAULT 0,
+    product_count INTEGER DEFAULT 0,
+    active_products INTEGER DEFAULT 0,
     -- Financial metrics
     total_value DECIMAL(15,3) DEFAULT 0,
     avg_margin DECIMAL(5,2),
@@ -157,255 +161,215 @@ CREATE TABLE IF NOT EXISTS category_metrics (
     -- Status
     status VARCHAR(20) DEFAULT 'active',
     PRIMARY KEY (category_id),
-    FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    INDEX idx_category_status (status),
-    INDEX idx_category_growth (growth_rate),
-    INDEX idx_metrics_last_calculated (last_calculated_at),
-    INDEX idx_category_metrics_products (product_count, active_products)
+    FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE
 );
 
+CREATE INDEX idx_category_status ON category_metrics(status);
+CREATE INDEX idx_category_growth ON category_metrics(growth_rate);
+CREATE INDEX idx_metrics_last_calculated_cat ON category_metrics(last_calculated_at);
+CREATE INDEX idx_category_metrics_products ON category_metrics(product_count, active_products);
+
 -- New table for vendor time-based metrics
-CREATE TABLE IF NOT EXISTS vendor_time_metrics (
+CREATE TABLE vendor_time_metrics (
     vendor VARCHAR(100) NOT NULL,
-    year INT NOT NULL,
-    month INT NOT NULL,
+    year INTEGER NOT NULL,
+    month INTEGER NOT NULL,
     -- Order metrics
-    total_orders INT DEFAULT 0,
-    late_orders INT DEFAULT 0,
+    total_orders INTEGER DEFAULT 0,
+    late_orders INTEGER DEFAULT 0,
     avg_lead_time_days DECIMAL(10,3),
     -- Financial metrics
     total_purchase_value DECIMAL(10,3) DEFAULT 0,
     total_revenue DECIMAL(10,3) DEFAULT 0,
     avg_margin_percent DECIMAL(5,2),
     PRIMARY KEY (vendor, year, month),
-    FOREIGN KEY (vendor) REFERENCES vendor_details(vendor) ON DELETE CASCADE,
-    INDEX idx_vendor_date (year, month)
+    FOREIGN KEY (vendor) REFERENCES vendor_details(vendor) ON DELETE CASCADE
 );
 
+CREATE INDEX idx_vendor_date ON vendor_time_metrics(year, month);
+
 -- New table for category time-based metrics
-CREATE TABLE IF NOT EXISTS category_time_metrics (
+CREATE TABLE category_time_metrics (
     category_id BIGINT NOT NULL,
-    year INT NOT NULL,
-    month INT NOT NULL,
+    year INTEGER NOT NULL,
+    month INTEGER NOT NULL,
     -- Product metrics
-    product_count INT DEFAULT 0,
-    active_products INT DEFAULT 0,
+    product_count INTEGER DEFAULT 0,
+    active_products INTEGER DEFAULT 0,
     -- Financial metrics
     total_value DECIMAL(15,3) DEFAULT 0,
     total_revenue DECIMAL(15,3) DEFAULT 0,
     avg_margin DECIMAL(5,2),
     turnover_rate DECIMAL(12,3),
     PRIMARY KEY (category_id, year, month),
-    FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    INDEX idx_category_date (year, month)
+    FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE
 );
 
+CREATE INDEX idx_category_date ON category_time_metrics(year, month);
+
 -- New table for category-based sales metrics
-CREATE TABLE IF NOT EXISTS category_sales_metrics (
+CREATE TABLE category_sales_metrics (
     category_id BIGINT NOT NULL,
     brand VARCHAR(100) NOT NULL,
     period_start DATE NOT NULL,
     period_end DATE NOT NULL,
     avg_daily_sales DECIMAL(10,3) DEFAULT 0,
-    total_sold INT DEFAULT 0,
-    num_products INT DEFAULT 0,
+    total_sold INTEGER DEFAULT 0,
+    num_products INTEGER DEFAULT 0,
     avg_price DECIMAL(10,3) DEFAULT 0,
     last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (category_id, brand, period_start, period_end),
-    FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    INDEX idx_category_brand (category_id, brand),
-    INDEX idx_period (period_start, period_end)
+    FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE
 );
 
+CREATE INDEX idx_category_brand ON category_sales_metrics(category_id, brand);
+CREATE INDEX idx_period ON category_sales_metrics(period_start, period_end);
+
 -- New table for brand metrics
-CREATE TABLE IF NOT EXISTS brand_metrics (
+CREATE TABLE brand_metrics (
     brand VARCHAR(100) NOT NULL,
     last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     -- Product metrics
-    product_count INT DEFAULT 0,
-    active_products INT DEFAULT 0,
+    product_count INTEGER DEFAULT 0,
+    active_products INTEGER DEFAULT 0,
     -- Stock metrics
-    total_stock_units INT DEFAULT 0,
+    total_stock_units INTEGER DEFAULT 0,
     total_stock_cost DECIMAL(15,2) DEFAULT 0,
     total_stock_retail DECIMAL(15,2) DEFAULT 0,
     -- Sales metrics
     total_revenue DECIMAL(15,2) DEFAULT 0,
     avg_margin DECIMAL(5,2) DEFAULT 0,
     growth_rate DECIMAL(5,2) DEFAULT 0,
-    PRIMARY KEY (brand),
-    INDEX idx_brand_metrics_last_calculated (last_calculated_at),
-    INDEX idx_brand_metrics_revenue (total_revenue),
-    INDEX idx_brand_metrics_growth (growth_rate)
+    PRIMARY KEY (brand)
 );
 
+CREATE INDEX idx_brand_metrics_last_calculated ON brand_metrics(last_calculated_at);
+CREATE INDEX idx_brand_metrics_revenue ON brand_metrics(total_revenue);
+CREATE INDEX idx_brand_metrics_growth ON brand_metrics(growth_rate);
+
 -- New table for brand time-based metrics
-CREATE TABLE IF NOT EXISTS brand_time_metrics (
+CREATE TABLE brand_time_metrics (
     brand VARCHAR(100) NOT NULL,
-    year INT NOT NULL,
-    month INT NOT NULL,
+    year INTEGER NOT NULL,
+    month INTEGER NOT NULL,
     -- Product metrics
-    product_count INT DEFAULT 0,
-    active_products INT DEFAULT 0,
+    product_count INTEGER DEFAULT 0,
+    active_products INTEGER DEFAULT 0,
     -- Stock metrics
-    total_stock_units INT DEFAULT 0,
+    total_stock_units INTEGER DEFAULT 0,
     total_stock_cost DECIMAL(15,2) DEFAULT 0,
     total_stock_retail DECIMAL(15,2) DEFAULT 0,
     -- Sales metrics
     total_revenue DECIMAL(15,2) DEFAULT 0,
     avg_margin DECIMAL(5,2) DEFAULT 0,
-    PRIMARY KEY (brand, year, month),
-    INDEX idx_brand_date (year, month)
+    growth_rate DECIMAL(5,2) DEFAULT 0,
+    PRIMARY KEY (brand, year, month)
 );
 
+CREATE INDEX idx_brand_time_date ON brand_time_metrics(year, month);
+
 -- New table for sales forecasts
-CREATE TABLE IF NOT EXISTS sales_forecasts (
+CREATE TABLE sales_forecasts (
     pid BIGINT NOT NULL,
     forecast_date DATE NOT NULL,
-    forecast_units DECIMAL(10,2) DEFAULT 0,
-    forecast_revenue DECIMAL(10,2) DEFAULT 0,
-    confidence_level DECIMAL(5,2) DEFAULT 0,
-    last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    forecast_quantity INTEGER,
+    confidence_level DECIMAL(5,2),
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (pid, forecast_date),
-    FOREIGN KEY (pid) REFERENCES products(pid) ON DELETE CASCADE,
-    INDEX idx_forecast_date (forecast_date),
-    INDEX idx_forecast_last_calculated (last_calculated_at)
+    FOREIGN KEY (pid) REFERENCES products(pid) ON DELETE CASCADE
 );
 
+CREATE INDEX idx_forecast_date ON sales_forecasts(forecast_date);
+
 -- New table for category forecasts
-CREATE TABLE IF NOT EXISTS category_forecasts (
+CREATE TABLE category_forecasts (
     category_id BIGINT NOT NULL,
     forecast_date DATE NOT NULL,
-    forecast_units DECIMAL(10,2) DEFAULT 0,
-    forecast_revenue DECIMAL(10,2) DEFAULT 0,
-    confidence_level DECIMAL(5,2) DEFAULT 0,
-    last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    forecast_revenue DECIMAL(15,2),
+    forecast_units INTEGER,
+    confidence_level DECIMAL(5,2),
+    created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
     PRIMARY KEY (category_id, forecast_date),
-    FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    INDEX idx_category_forecast_date (forecast_date),
-    INDEX idx_category_forecast_last_calculated (last_calculated_at)
+    FOREIGN KEY (category_id) REFERENCES categories(cat_id) ON DELETE CASCADE
 );
 
--- Create view for inventory health
+CREATE INDEX idx_cat_forecast_date ON category_forecasts(forecast_date);
+
+-- Create views for common calculations
 CREATE OR REPLACE VIEW inventory_health AS
-WITH product_thresholds AS (
+WITH stock_levels AS (
     SELECT 
         p.pid,
-        COALESCE(
-            -- Try category+vendor specific
-            (SELECT critical_days FROM stock_thresholds st 
-            JOIN product_categories pc ON st.category_id = pc.cat_id
-            WHERE pc.pid = p.pid 
-            AND st.vendor = p.vendor LIMIT 1),
-            -- Try category specific
-            (SELECT critical_days FROM stock_thresholds st 
-            JOIN product_categories pc ON st.category_id = pc.cat_id
-            WHERE pc.pid = p.pid 
-            AND st.vendor IS NULL LIMIT 1),
-            -- Try vendor specific
-            (SELECT critical_days FROM stock_thresholds st 
-            WHERE st.category_id IS NULL 
-            AND st.vendor = p.vendor LIMIT 1),
-            -- Fall back to default
-            (SELECT critical_days FROM stock_thresholds st 
-            WHERE st.category_id IS NULL 
-            AND st.vendor IS NULL LIMIT 1),
-            7
-        ) as critical_days,
-        COALESCE(
-            -- Try category+vendor specific
-            (SELECT reorder_days FROM stock_thresholds st 
-            JOIN product_categories pc ON st.category_id = pc.cat_id
-            WHERE pc.pid = p.pid 
-            AND st.vendor = p.vendor LIMIT 1),
-            -- Try category specific
-            (SELECT reorder_days FROM stock_thresholds st 
-            JOIN product_categories pc ON st.category_id = pc.cat_id
-            WHERE pc.pid = p.pid 
-            AND st.vendor IS NULL LIMIT 1),
-            -- Try vendor specific
-            (SELECT reorder_days FROM stock_thresholds st 
-            WHERE st.category_id IS NULL 
-            AND st.vendor = p.vendor LIMIT 1),
-            -- Fall back to default
-            (SELECT reorder_days FROM stock_thresholds st 
-            WHERE st.category_id IS NULL 
-            AND st.vendor IS NULL LIMIT 1),
-            14
-        ) as reorder_days,
-        COALESCE(
-            -- Try category+vendor specific
-            (SELECT overstock_days FROM stock_thresholds st 
-            JOIN product_categories pc ON st.category_id = pc.cat_id
-            WHERE pc.pid = p.pid 
-            AND st.vendor = p.vendor LIMIT 1),
-            -- Try category specific
-            (SELECT overstock_days FROM stock_thresholds st 
-            JOIN product_categories pc ON st.category_id = pc.cat_id
-            WHERE pc.pid = p.pid 
-            AND st.vendor IS NULL LIMIT 1),
-            -- Try vendor specific
-            (SELECT overstock_days FROM stock_thresholds st 
-            WHERE st.category_id IS NULL 
-            AND st.vendor = p.vendor LIMIT 1),
-            -- Fall back to default
-            (SELECT overstock_days FROM stock_thresholds st 
-            WHERE st.category_id IS NULL 
-            AND st.vendor IS NULL LIMIT 1),
-            90
-        ) as overstock_days
+        p.title,
+        p.SKU,
+        p.stock_quantity,
+        p.preorder_count,
+        pm.daily_sales_avg,
+        pm.weekly_sales_avg,
+        pm.monthly_sales_avg,
+        pm.reorder_point,
+        pm.safety_stock,
+        pm.days_of_inventory,
+        pm.weeks_of_inventory,
+        pm.stock_status,
+        pm.abc_class,
+        pm.turnover_rate,
+        pm.avg_lead_time_days,
+        pm.current_lead_time,
+        pm.target_lead_time,
+        pm.lead_time_status,
+        p.cost_price,
+        p.price,
+        pm.inventory_value,
+        pm.gmroi
     FROM products p
+    LEFT JOIN product_metrics pm ON p.pid = pm.pid
+    WHERE p.managing_stock = true AND p.visible = true
 )
 SELECT 
-    p.pid,
-    p.SKU,
-    p.title,
-    p.stock_quantity,
-    COALESCE(pm.daily_sales_avg, 0) as daily_sales_avg,
-    COALESCE(pm.days_of_inventory, 0) as days_of_inventory,
-    COALESCE(pm.reorder_point, 0) as reorder_point,
-    COALESCE(pm.safety_stock, 0) as safety_stock,
+    *,
     CASE 
-        WHEN pm.daily_sales_avg = 0 THEN 'New'
-        WHEN p.stock_quantity <= CEIL(pm.daily_sales_avg * pt.critical_days) THEN 'Critical'
-        WHEN p.stock_quantity <= CEIL(pm.daily_sales_avg * pt.reorder_days) THEN 'Reorder'
-        WHEN p.stock_quantity > (pm.daily_sales_avg * pt.overstock_days) THEN 'Overstocked'
+        WHEN stock_quantity <= safety_stock THEN 'Critical'
+        WHEN stock_quantity <= reorder_point THEN 'Low'
+        WHEN stock_quantity > (reorder_point * 3) THEN 'Excess'
         ELSE 'Healthy'
-    END as stock_status
-FROM 
-    products p
-LEFT JOIN 
-    product_metrics pm ON p.pid = pm.pid
-LEFT JOIN
-    product_thresholds pt ON p.pid = pt.pid
-WHERE 
-    p.managing_stock = true;
+    END as inventory_status,
+    CASE 
+        WHEN lead_time_status = 'delayed' AND stock_status = 'low' THEN 'High'
+        WHEN lead_time_status = 'delayed' OR stock_status = 'low' THEN 'Medium'
+        ELSE 'Low'
+    END as risk_level
+FROM stock_levels;
 
 -- Create view for category performance trends
 CREATE OR REPLACE VIEW category_performance_trends AS
+WITH monthly_trends AS (
+    SELECT 
+        c.cat_id,
+        c.name as category_name,
+        ctm.year,
+        ctm.month,
+        ctm.product_count,
+        ctm.active_products,
+        ctm.total_value,
+        ctm.total_revenue,
+        ctm.avg_margin,
+        ctm.turnover_rate,
+        LAG(ctm.total_revenue) OVER (PARTITION BY c.cat_id ORDER BY ctm.year, ctm.month) as prev_month_revenue,
+        LAG(ctm.turnover_rate) OVER (PARTITION BY c.cat_id ORDER BY ctm.year, ctm.month) as prev_month_turnover
+    FROM categories c
+    JOIN category_time_metrics ctm ON c.cat_id = ctm.category_id
+)
 SELECT 
-    c.cat_id as category_id,
-    c.name,
-    c.description,
-    p.name as parent_name,
-    c.status,
-    cm.product_count,
-    cm.active_products,
-    cm.total_value,
-    cm.avg_margin,
-    cm.turnover_rate,
-    cm.growth_rate,
+    *,
     CASE 
-        WHEN cm.growth_rate >= 20 THEN 'High Growth'
-        WHEN cm.growth_rate >= 5 THEN 'Growing'
-        WHEN cm.growth_rate >= -5 THEN 'Stable'
-        ELSE 'Declining'
-    END as performance_rating
-FROM 
-    categories c
-LEFT JOIN 
-    categories p ON c.parent_id = p.cat_id
-LEFT JOIN 
-    category_metrics cm ON c.cat_id = cm.category_id;
+        WHEN prev_month_revenue IS NULL THEN 0
+        ELSE ((total_revenue - prev_month_revenue) / prev_month_revenue) * 100 
+    END as revenue_growth_percent,
+    CASE 
+        WHEN prev_month_turnover IS NULL THEN 0
+        ELSE ((turnover_rate - prev_month_turnover) / prev_month_turnover) * 100 
+    END as turnover_growth_percent
+FROM monthly_trends;
 
--- Re-enable foreign key checks
-SET FOREIGN_KEY_CHECKS = 1;
+SET session_replication_role = 'origin';

inventory-server/db/schema.sql

@@ -1,6 +1,13 @@
 -- Enable strict error reporting
-SET sql_mode = 'STRICT_ALL_TABLES,ERROR_FOR_DIVISION_BY_ZERO,NO_ZERO_DATE,NO_ZERO_IN_DATE,NO_ENGINE_SUBSTITUTION';
-SET FOREIGN_KEY_CHECKS = 0;
+SET session_replication_role = 'replica';  -- Disable foreign key checks temporarily
+
+-- Create function for updating timestamps
+CREATE OR REPLACE FUNCTION update_updated_column() RETURNS TRIGGER AS $func$
+BEGIN
+    NEW.updated = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$func$ language plpgsql;
 
 -- Create tables
 CREATE TABLE products (
@@ -8,18 +15,18 @@ CREATE TABLE products (
     title VARCHAR(255) NOT NULL,
     description TEXT,
     SKU VARCHAR(50) NOT NULL,
-    created_at TIMESTAMP NULL,
-    first_received TIMESTAMP NULL,
-    stock_quantity INT DEFAULT 0,
-    preorder_count INT DEFAULT 0,
-    notions_inv_count INT DEFAULT 0,
+    created_at TIMESTAMP WITH TIME ZONE,
+    first_received TIMESTAMP WITH TIME ZONE,
+    stock_quantity INTEGER DEFAULT 0,
+    preorder_count INTEGER DEFAULT 0,
+    notions_inv_count INTEGER DEFAULT 0,
     price DECIMAL(10, 3) NOT NULL,
     regular_price DECIMAL(10, 3) NOT NULL,
     cost_price DECIMAL(10, 3),
     landing_cost_price DECIMAL(10, 3),
     barcode VARCHAR(50),
     harmonized_tariff_code VARCHAR(20),
-    updated_at TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE,
     visible BOOLEAN DEFAULT true,
     managing_stock BOOLEAN DEFAULT true,
     replenishable BOOLEAN DEFAULT true,
@@ -37,47 +44,64 @@ CREATE TABLE products (
     artist VARCHAR(100),
     options TEXT,
     tags TEXT,
-    moq INT DEFAULT 1,
-    uom INT DEFAULT 1,
+    moq INTEGER DEFAULT 1,
+    uom INTEGER DEFAULT 1,
     rating DECIMAL(10,2) DEFAULT 0.00,
-    reviews INT UNSIGNED DEFAULT 0,
+    reviews INTEGER DEFAULT 0,
     weight DECIMAL(10,3),
     length DECIMAL(10,3),
     width DECIMAL(10,3),
     height DECIMAL(10,3),
     country_of_origin VARCHAR(5),
     location VARCHAR(50),
-    total_sold INT UNSIGNED DEFAULT 0,
-    baskets INT UNSIGNED DEFAULT 0,
-    notifies INT UNSIGNED DEFAULT 0,
+    total_sold INTEGER DEFAULT 0,
+    baskets INTEGER DEFAULT 0,
+    notifies INTEGER DEFAULT 0,
     date_last_sold DATE,
-    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-    PRIMARY KEY (pid),
-    INDEX idx_sku (SKU),
-    INDEX idx_vendor (vendor),
-    INDEX idx_brand (brand),
-    INDEX idx_location (location),
-    INDEX idx_total_sold (total_sold),
-    INDEX idx_date_last_sold (date_last_sold),
-    INDEX idx_updated (updated)
-) ENGINE=InnoDB;
+    updated TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    PRIMARY KEY (pid)
+);
+
+-- Create trigger for products
+CREATE TRIGGER update_products_updated
+    BEFORE UPDATE ON products
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_column();
+
+-- Create indexes for products table
+CREATE INDEX idx_products_sku ON products(SKU);
+CREATE INDEX idx_products_vendor ON products(vendor);
+CREATE INDEX idx_products_brand ON products(brand);
+CREATE INDEX idx_products_location ON products(location);
+CREATE INDEX idx_products_total_sold ON products(total_sold);
+CREATE INDEX idx_products_date_last_sold ON products(date_last_sold);
+CREATE INDEX idx_products_updated ON products(updated);
 
 -- Create categories table with hierarchy support
 CREATE TABLE categories (
     cat_id BIGINT PRIMARY KEY,
     name VARCHAR(100) NOT NULL,
-    type SMALLINT NOT NULL COMMENT '10=section, 11=category, 12=subcategory, 13=subsubcategory, 1=company, 2=line, 3=subline, 40=artist',
+    type SMALLINT NOT NULL,
     parent_id BIGINT,
     description TEXT,
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
     status VARCHAR(20) DEFAULT 'active',
-    FOREIGN KEY (parent_id) REFERENCES categories(cat_id),
-    INDEX idx_parent (parent_id),
-    INDEX idx_type (type),
-    INDEX idx_status (status),
-    INDEX idx_name_type (name, type)
-) ENGINE=InnoDB;
+    FOREIGN KEY (parent_id) REFERENCES categories(cat_id)
+);
+
+-- Create trigger for categories
+CREATE TRIGGER update_categories_updated_at
+    BEFORE UPDATE ON categories
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_column();
+
+COMMENT ON COLUMN categories.type IS '10=section, 11=category, 12=subcategory, 13=subsubcategory, 1=company, 2=line, 3=subline, 40=artist';
+
+CREATE INDEX idx_categories_parent ON categories(parent_id);
+CREATE INDEX idx_categories_type ON categories(type);
+CREATE INDEX idx_categories_status ON categories(status);
+CREATE INDEX idx_categories_name_type ON categories(name, type);
 
 -- Create product_categories junction table
 CREATE TABLE product_categories (
@@ -85,78 +109,98 @@ CREATE TABLE product_categories (
     pid BIGINT NOT NULL,
     PRIMARY KEY (pid, cat_id),
     FOREIGN KEY (pid) REFERENCES products(pid) ON DELETE CASCADE,
-    FOREIGN KEY (cat_id) REFERENCES categories(cat_id) ON DELETE CASCADE,
-    INDEX idx_category (cat_id),
-    INDEX idx_product (pid)
-) ENGINE=InnoDB;
+    FOREIGN KEY (cat_id) REFERENCES categories(cat_id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_product_categories_category ON product_categories(cat_id);
+CREATE INDEX idx_product_categories_product ON product_categories(pid);
 
 -- Create orders table with its indexes
-CREATE TABLE IF NOT EXISTS orders (
-    id BIGINT NOT NULL AUTO_INCREMENT,
+CREATE TABLE orders (
+    id BIGSERIAL PRIMARY KEY,
     order_number VARCHAR(50) NOT NULL,
     pid BIGINT NOT NULL,
     SKU VARCHAR(50) NOT NULL,
     date DATE NOT NULL,
     price DECIMAL(10,3) NOT NULL,
-    quantity INT NOT NULL,
+    quantity INTEGER NOT NULL,
     discount DECIMAL(10,3) DEFAULT 0.000,
     tax DECIMAL(10,3) DEFAULT 0.000,
-    tax_included TINYINT(1) DEFAULT 0,
+    tax_included BOOLEAN DEFAULT false,
     shipping DECIMAL(10,3) DEFAULT 0.000,
     costeach DECIMAL(10,3) DEFAULT 0.000,
     customer VARCHAR(50) NOT NULL,
     customer_name VARCHAR(100),
     status VARCHAR(20) DEFAULT 'pending',
-    canceled TINYINT(1) DEFAULT 0,
-    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
-    PRIMARY KEY (id),
-    UNIQUE KEY unique_order_line (order_number, pid),
-    KEY order_number (order_number),
-    KEY pid (pid),
-    KEY customer (customer),
-    KEY date (date),
-    KEY status (status),
-    INDEX idx_orders_metrics (pid, date, canceled),
-    INDEX idx_updated (updated)
-) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;
+    canceled BOOLEAN DEFAULT false,
+    updated TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE (order_number, pid)
+);
+
+-- Create trigger for orders
+CREATE TRIGGER update_orders_updated
+    BEFORE UPDATE ON orders
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_column();
+
+CREATE INDEX idx_orders_number ON orders(order_number);
+CREATE INDEX idx_orders_pid ON orders(pid);
+CREATE INDEX idx_orders_customer ON orders(customer);
+CREATE INDEX idx_orders_date ON orders(date);
+CREATE INDEX idx_orders_status ON orders(status);
+CREATE INDEX idx_orders_metrics ON orders(pid, date, canceled);
+CREATE INDEX idx_orders_updated ON orders(updated);
 
 -- Create purchase_orders table with its indexes
 CREATE TABLE purchase_orders (
-    id BIGINT AUTO_INCREMENT PRIMARY KEY,
+    id BIGSERIAL PRIMARY KEY,
     po_id VARCHAR(50) NOT NULL,
     vendor VARCHAR(100) NOT NULL,
     date DATE NOT NULL,
     expected_date DATE,
     pid BIGINT NOT NULL,
     sku VARCHAR(50) NOT NULL,
-    name VARCHAR(100) NOT NULL COMMENT 'Product name from products.description',
+    name VARCHAR(100) NOT NULL,
     cost_price DECIMAL(10, 3) NOT NULL,
-    po_cost_price DECIMAL(10, 3) NOT NULL COMMENT 'Original cost from PO, before receiving adjustments',
-    status TINYINT UNSIGNED DEFAULT 1 COMMENT '0=canceled,1=created,10=electronically_ready_send,11=ordered,12=preordered,13=electronically_sent,15=receiving_started,50=done',
-    receiving_status TINYINT UNSIGNED DEFAULT 1 COMMENT '0=canceled,1=created,30=partial_received,40=full_received,50=paid',
+    po_cost_price DECIMAL(10, 3) NOT NULL,
+    status SMALLINT DEFAULT 1,
+    receiving_status SMALLINT DEFAULT 1,
     notes TEXT,
     long_note TEXT,
-    ordered INT NOT NULL,
-    received INT DEFAULT 0,
-    received_date DATE COMMENT 'Date of first receiving',
-    last_received_date DATE COMMENT 'Date of most recent receiving',
-    received_by VARCHAR(100) COMMENT 'Name of person who first received this PO line',
-    receiving_history JSON COMMENT 'Array of receiving records with qty, date, cost, receiving_id, and alt_po flag',
-    updated TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
+    ordered INTEGER NOT NULL,
+    received INTEGER DEFAULT 0,
+    received_date DATE,
+    last_received_date DATE,
+    received_by VARCHAR(100),
+    receiving_history JSONB,
+    updated TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
     FOREIGN KEY (pid) REFERENCES products(pid),
-    INDEX idx_po_id (po_id),
-    INDEX idx_vendor (vendor),
-    INDEX idx_status (status),
-    INDEX idx_receiving_status (receiving_status),
-    INDEX idx_purchase_orders_metrics (pid, date, status, ordered, received),
-    INDEX idx_po_metrics (pid, date, receiving_status, received_date),
-    INDEX idx_po_product_date (pid, date),
-    INDEX idx_po_product_status (pid, status),
-    INDEX idx_updated (updated),
-    UNIQUE KEY unique_po_product (po_id, pid)
-) ENGINE=InnoDB;
+    UNIQUE (po_id, pid)
+);
 
-SET FOREIGN_KEY_CHECKS = 1;
+-- Create trigger for purchase_orders
+CREATE TRIGGER update_purchase_orders_updated
+    BEFORE UPDATE ON purchase_orders
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_column();
+
+COMMENT ON COLUMN purchase_orders.name IS 'Product name from products.description';
+COMMENT ON COLUMN purchase_orders.po_cost_price IS 'Original cost from PO, before receiving adjustments';
+COMMENT ON COLUMN purchase_orders.status IS '0=canceled,1=created,10=electronically_ready_send,11=ordered,12=preordered,13=electronically_sent,15=receiving_started,50=done';
+COMMENT ON COLUMN purchase_orders.receiving_status IS '0=canceled,1=created,30=partial_received,40=full_received,50=paid';
+COMMENT ON COLUMN purchase_orders.receiving_history IS 'Array of receiving records with qty, date, cost, receiving_id, and alt_po flag';
+
+CREATE INDEX idx_po_id ON purchase_orders(po_id);
+CREATE INDEX idx_po_vendor ON purchase_orders(vendor);
+CREATE INDEX idx_po_status ON purchase_orders(status);
+CREATE INDEX idx_po_receiving_status ON purchase_orders(receiving_status);
+CREATE INDEX idx_po_metrics ON purchase_orders(pid, date, status, ordered, received);
+CREATE INDEX idx_po_metrics_receiving ON purchase_orders(pid, date, receiving_status, received_date);
+CREATE INDEX idx_po_product_date ON purchase_orders(pid, date);
+CREATE INDEX idx_po_product_status ON purchase_orders(pid, status);
+CREATE INDEX idx_po_updated ON purchase_orders(updated);
+
+SET session_replication_role = 'origin';  -- Re-enable foreign key checks
 
 -- Create views for common calculations
 -- product_sales_trends view moved to metrics-schema.sql 

inventory-server/db/setup-schema.sql

@@ -0,0 +1,53 @@
+-- Templates table for storing import templates
+CREATE TABLE IF NOT EXISTS templates (
+    id SERIAL PRIMARY KEY,
+    company TEXT NOT NULL,
+    product_type TEXT NOT NULL,
+    supplier TEXT,
+    msrp DECIMAL(10,2),
+    cost_each DECIMAL(10,2),
+    qty_per_unit INTEGER,
+    case_qty INTEGER,
+    hts_code TEXT,
+    description TEXT,
+    weight DECIMAL(10,2),
+    length DECIMAL(10,2),
+    width DECIMAL(10,2),
+    height DECIMAL(10,2),
+    tax_cat TEXT,
+    size_cat TEXT,
+    categories TEXT[],
+    ship_restrictions TEXT[],
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(company, product_type)
+);
+
+-- AI Validation Performance Tracking
+CREATE TABLE IF NOT EXISTS ai_validation_performance (
+    id SERIAL PRIMARY KEY,
+    prompt_length INTEGER NOT NULL,
+    product_count INTEGER NOT NULL,
+    start_time TIMESTAMP WITH TIME ZONE NOT NULL,
+    end_time TIMESTAMP WITH TIME ZONE NOT NULL,
+    duration_seconds DECIMAL(10,2) GENERATED ALWAYS AS (EXTRACT(EPOCH FROM (end_time - start_time))) STORED,
+    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP
+);
+
+-- Create index on prompt_length for efficient querying
+CREATE INDEX IF NOT EXISTS idx_ai_validation_prompt_length ON ai_validation_performance(prompt_length);
+
+-- Function to update the updated_at timestamp
+CREATE OR REPLACE FUNCTION update_updated_at_column()
+RETURNS TRIGGER AS $$
+BEGIN
+    NEW.updated_at = CURRENT_TIMESTAMP;
+    RETURN NEW;
+END;
+$$ language 'plpgsql';
+
+-- Trigger to automatically update the updated_at column
+CREATE TRIGGER update_templates_updated_at
+    BEFORE UPDATE ON templates
+    FOR EACH ROW
+    EXECUTE FUNCTION update_updated_at_column(); 

inventory-server/package.json

@@ -18,12 +18,18 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
+    "@types/diff": "^7.0.1",
+    "axios": "^1.8.1",
+    "bcrypt": "^5.1.1",
     "cors": "^2.8.5",
     "csv-parse": "^5.6.0",
+    "diff": "^7.0.0",
     "dotenv": "^16.4.7",
     "express": "^4.18.2",
     "multer": "^1.4.5-lts.1",
     "mysql2": "^3.12.0",
+    "openai": "^4.85.3",
+    "pg": "^8.13.3",
     "pm2": "^5.3.0",
     "ssh2": "^1.16.0",
     "uuid": "^9.0.1"

inventory-server/scripts/full-reset.js

@@ -14,7 +14,15 @@ function outputProgress(data) {
 function runScript(scriptPath) {
     return new Promise((resolve, reject) => {
         const child = spawn('node', [scriptPath], {
-            stdio: ['inherit', 'pipe', 'pipe']
+            stdio: ['inherit', 'pipe', 'pipe'],
+            env: {
+                ...process.env,
+                PGHOST: process.env.DB_HOST,
+                PGUSER: process.env.DB_USER,
+                PGPASSWORD: process.env.DB_PASSWORD,
+                PGDATABASE: process.env.DB_NAME,
+                PGPORT: process.env.DB_PORT || '5432'
+            }
         });
 
         let output = '';

inventory-server/scripts/import-from-prod.js

@@ -19,7 +19,6 @@ const IMPORT_PURCHASE_ORDERS = true;
 const INCREMENTAL_UPDATE = process.env.INCREMENTAL_UPDATE !== 'false';  // Default to true unless explicitly set to false
 
 // SSH configuration
-// In import-from-prod.js
 const sshConfig = {
   ssh: {
     host: process.env.PROD_SSH_HOST,
@@ -31,6 +30,7 @@ const sshConfig = {
     compress: true, // Enable SSH compression
   },
   prodDbConfig: {
+    // MySQL config for production
     host: process.env.PROD_DB_HOST || "localhost",
     user: process.env.PROD_DB_USER,
     password: process.env.PROD_DB_PASSWORD,
@@ -39,21 +39,16 @@ const sshConfig = {
     timezone: 'Z',
   },
   localDbConfig: {
+    // PostgreSQL config for local
     host: process.env.DB_HOST,
     user: process.env.DB_USER,
     password: process.env.DB_PASSWORD,
     database: process.env.DB_NAME,
-    multipleStatements: true,
-    waitForConnections: true,
-    connectionLimit: 10,
-    queueLimit: 0,
-    namedPlaceholders: true,
-    connectTimeout: 60000,
-    enableKeepAlive: true,
-    keepAliveInitialDelay: 10000,
-    compress: true,
-    timezone: 'Z',
-    stringifyObjects: false,
+    port: process.env.DB_PORT || 5432,
+    ssl: process.env.DB_SSL === 'true',
+    connectionTimeoutMillis: 60000,
+    idleTimeoutMillis: 30000,
+    max: 10 // connection pool max size
   }
 };
 
@@ -108,7 +103,7 @@ async function main() {
       SET 
         status = 'cancelled',
         end_time = NOW(),
-        duration_seconds = TIMESTAMPDIFF(SECOND, start_time, NOW()),
+        duration_seconds = EXTRACT(EPOCH FROM (NOW() - start_time))::INTEGER,
         error_message = 'Previous import was not completed properly'
       WHERE status = 'running'
     `);
@@ -118,9 +113,10 @@ async function main() {
       CREATE TABLE IF NOT EXISTS sync_status (
         table_name VARCHAR(50) PRIMARY KEY,
         last_sync_timestamp TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-        last_sync_id BIGINT,
-        INDEX idx_last_sync (last_sync_timestamp)
+        last_sync_id BIGINT
       );
+
+      CREATE INDEX IF NOT EXISTS idx_last_sync ON sync_status (last_sync_timestamp);
     `);
 
     // Create import history record for the overall session
@@ -134,17 +130,17 @@ async function main() {
       ) VALUES (
         'all_tables',
         NOW(),
-        ?,
+        $1::boolean,
         'running',
-        JSON_OBJECT(
-          'categories_enabled', ?,
-          'products_enabled', ?,
-          'orders_enabled', ?,
-          'purchase_orders_enabled', ?
+        jsonb_build_object(
+          'categories_enabled', $2::boolean,
+          'products_enabled', $3::boolean,
+          'orders_enabled', $4::boolean,
+          'purchase_orders_enabled', $5::boolean
         )
-      )
+      ) RETURNING id
     `, [INCREMENTAL_UPDATE, IMPORT_CATEGORIES, IMPORT_PRODUCTS, IMPORT_ORDERS, IMPORT_PURCHASE_ORDERS]);
-    importHistoryId = historyResult.insertId;
+    importHistoryId = historyResult.rows[0].id;
 
     const results = {
       categories: null,
@@ -162,8 +158,8 @@ async function main() {
       if (isImportCancelled) throw new Error("Import cancelled");
       completedSteps++;
       console.log('Categories import result:', results.categories);
-      totalRecordsAdded += results.categories?.recordsAdded || 0;
-      totalRecordsUpdated += results.categories?.recordsUpdated || 0;
+      totalRecordsAdded += parseInt(results.categories?.recordsAdded || 0);
+      totalRecordsUpdated += parseInt(results.categories?.recordsUpdated || 0);
     }
 
     if (IMPORT_PRODUCTS) {
@@ -171,8 +167,8 @@ async function main() {
       if (isImportCancelled) throw new Error("Import cancelled");
       completedSteps++;
       console.log('Products import result:', results.products);
-      totalRecordsAdded += results.products?.recordsAdded || 0;
-      totalRecordsUpdated += results.products?.recordsUpdated || 0;
+      totalRecordsAdded += parseInt(results.products?.recordsAdded || 0);
+      totalRecordsUpdated += parseInt(results.products?.recordsUpdated || 0);
     }
 
     if (IMPORT_ORDERS) {
@@ -180,8 +176,8 @@ async function main() {
       if (isImportCancelled) throw new Error("Import cancelled");
       completedSteps++;
       console.log('Orders import result:', results.orders);
-      totalRecordsAdded += results.orders?.recordsAdded || 0;
-      totalRecordsUpdated += results.orders?.recordsUpdated || 0;
+      totalRecordsAdded += parseInt(results.orders?.recordsAdded || 0);
+      totalRecordsUpdated += parseInt(results.orders?.recordsUpdated || 0);
     }
 
     if (IMPORT_PURCHASE_ORDERS) {
@@ -189,8 +185,8 @@ async function main() {
       if (isImportCancelled) throw new Error("Import cancelled");
       completedSteps++;
       console.log('Purchase orders import result:', results.purchaseOrders);
-      totalRecordsAdded += results.purchaseOrders?.recordsAdded || 0;
-      totalRecordsUpdated += results.purchaseOrders?.recordsUpdated || 0;
+      totalRecordsAdded += parseInt(results.purchaseOrders?.recordsAdded || 0);
+      totalRecordsUpdated += parseInt(results.purchaseOrders?.recordsUpdated || 0);
     }
 
     const endTime = Date.now();
@@ -201,21 +197,21 @@ async function main() {
       UPDATE import_history 
       SET 
         end_time = NOW(),
-        duration_seconds = ?,
-        records_added = ?,
-        records_updated = ?,
+        duration_seconds = $1,
+        records_added = $2,
+        records_updated = $3,
         status = 'completed',
-        additional_info = JSON_OBJECT(
-          'categories_enabled', ?,
-          'products_enabled', ?,
-          'orders_enabled', ?,
-          'purchase_orders_enabled', ?,
-          'categories_result', CAST(? AS JSON),
-          'products_result', CAST(? AS JSON),
-          'orders_result', CAST(? AS JSON),
-          'purchase_orders_result', CAST(? AS JSON)
+        additional_info = jsonb_build_object(
+          'categories_enabled', $4::boolean,
+          'products_enabled', $5::boolean,
+          'orders_enabled', $6::boolean,
+          'purchase_orders_enabled', $7::boolean,
+          'categories_result', COALESCE($8::jsonb, 'null'::jsonb),
+          'products_result', COALESCE($9::jsonb, 'null'::jsonb),
+          'orders_result', COALESCE($10::jsonb, 'null'::jsonb),
+          'purchase_orders_result', COALESCE($11::jsonb, 'null'::jsonb)
         )
-      WHERE id = ?
+      WHERE id = $12
     `, [
       totalElapsedSeconds,
       totalRecordsAdded,
@@ -259,10 +255,10 @@ async function main() {
         UPDATE import_history 
         SET 
           end_time = NOW(),
-          duration_seconds = ?,
-          status = ?,
-          error_message = ?
-        WHERE id = ?
+          duration_seconds = $1,
+          status = $2,
+          error_message = $3
+        WHERE id = $4
       `, [totalElapsedSeconds, error.message === "Import cancelled" ? 'cancelled' : 'failed', error.message, importHistoryId]);
     }
 
@@ -288,16 +284,23 @@ async function main() {
     throw error;
   } finally {
     if (connections) {
-      await closeConnections(connections);
+      await closeConnections(connections).catch(err => {
+        console.error("Error closing connections:", err);
+      });
     }
   }
 }
 
 // Run the import only if this is the main module
 if (require.main === module) {
-  main().catch((error) => {
+  main().then((results) => {
+    console.log('Import completed successfully:', results);
+    // Force exit after a small delay to ensure all logs are written
+    setTimeout(() => process.exit(0), 500);
+  }).catch((error) => {
     console.error("Unhandled error in main process:", error);
-    process.exit(1);
+    // Force exit with error code after a small delay
+    setTimeout(() => process.exit(1), 500);
   });
 }
 

inventory-server/scripts/import/categories.js

@@ -9,170 +9,206 @@ async function importCategories(prodConnection, localConnection) {
   const startTime = Date.now();
   const typeOrder = [10, 20, 11, 21, 12, 13];
   let totalInserted = 0;
+  let totalUpdated = 0;
   let skippedCategories = [];
 
   try {
-    // Process each type in order with its own query
+    // Start a single transaction for the entire import
+    await localConnection.query('BEGIN');
+
+    // Process each type in order with its own savepoint
     for (const type of typeOrder) {
-      const [categories] = await prodConnection.query(
-        `
-        SELECT 
-          pc.cat_id,
-          pc.name,
-          pc.type,
-          CASE 
-            WHEN pc.type IN (10, 20) THEN NULL  -- Top level categories should have no parent
-            WHEN pc.master_cat_id IS NULL THEN NULL
-            ELSE pc.master_cat_id
-          END as parent_id,
-          pc.combined_name as description
-        FROM product_categories pc
-        WHERE pc.type = ?
-        ORDER BY pc.cat_id
-      `,
-        [type]
-      );
+      try {
+        // Create a savepoint for this type
+        await localConnection.query(`SAVEPOINT category_type_${type}`);
 
-      if (categories.length === 0) continue;
-
-      console.log(`\nProcessing ${categories.length} type ${type} categories`);
-      if (type === 10) {
-        console.log("Type 10 categories:", JSON.stringify(categories, null, 2));
-      }
-
-      // For types that can have parents (11, 21, 12, 13), verify parent existence
-      let categoriesToInsert = categories;
-      if (![10, 20].includes(type)) {
-        // Get all parent IDs
-        const parentIds = [
-          ...new Set(
-            categories.map((c) => c.parent_id).filter((id) => id !== null)
-          ),
-        ];
-
-        // Check which parents exist
-        const [existingParents] = await localConnection.query(
-          "SELECT cat_id FROM categories WHERE cat_id IN (?)",
-          [parentIds]
-        );
-        const existingParentIds = new Set(existingParents.map((p) => p.cat_id));
-
-        // Filter categories and track skipped ones
-        categoriesToInsert = categories.filter(
-          (cat) =>
-            cat.parent_id === null || existingParentIds.has(cat.parent_id)
-        );
-        const invalidCategories = categories.filter(
-          (cat) =>
-            cat.parent_id !== null && !existingParentIds.has(cat.parent_id)
+        // Production query remains MySQL compatible
+        const [categories] = await prodConnection.query(
+          `
+          SELECT 
+            pc.cat_id,
+            pc.name,
+            pc.type,
+            CASE 
+              WHEN pc.type IN (10, 20) THEN NULL  -- Top level categories should have no parent
+              WHEN pc.master_cat_id IS NULL THEN NULL
+              ELSE pc.master_cat_id
+            END as parent_id,
+            pc.combined_name as description
+          FROM product_categories pc
+          WHERE pc.type = ?
+          ORDER BY pc.cat_id
+        `,
+          [type]
         );
 
-        if (invalidCategories.length > 0) {
-          const skippedInfo = invalidCategories.map((c) => ({
-            id: c.cat_id,
-            name: c.name,
-            type: c.type,
-            missing_parent: c.parent_id,
-          }));
-          skippedCategories.push(...skippedInfo);
+        if (categories.length === 0) {
+          await localConnection.query(`RELEASE SAVEPOINT category_type_${type}`);
+          continue;
+        }
 
-          console.log(
-            "\nSkipping categories with missing parents:",
-            invalidCategories
-              .map(
-                (c) =>
-                  `${c.cat_id} - ${c.name} (missing parent: ${c.parent_id})`
-              )
-              .join("\n")
-          );
+        console.log(`\nProcessing ${categories.length} type ${type} categories`);
+        if (type === 10) {
+          console.log("Type 10 categories:", JSON.stringify(categories, null, 2));
+        }
+
+        // For types that can have parents (11, 21, 12, 13), verify parent existence
+        let categoriesToInsert = categories;
+        if (![10, 20].includes(type)) {
+          // Get all parent IDs
+          const parentIds = [
+            ...new Set(
+              categories
+                .filter(c => c && c.parent_id !== null)
+                .map(c => c.parent_id)
+            ),
+          ];
+
+          console.log(`Processing ${categories.length} type ${type} categories with ${parentIds.length} unique parent IDs`);
+          console.log('Parent IDs:', parentIds);
+
+          // No need to check for parent existence - we trust they exist since they were just inserted
+          categoriesToInsert = categories;
         }
 
         if (categoriesToInsert.length === 0) {
           console.log(
-            `No valid categories of type ${type} to insert - all had missing parents`
+            `No valid categories of type ${type} to insert`
           );
+          await localConnection.query(`RELEASE SAVEPOINT category_type_${type}`);
           continue;
         }
+
+        console.log(
+          `Inserting ${categoriesToInsert.length} type ${type} categories`
+        );
+
+        // PostgreSQL upsert query with parameterized values
+        const values = categoriesToInsert.flatMap((cat) => [
+          cat.cat_id,
+          cat.name,
+          cat.type,
+          cat.parent_id,
+          cat.description,
+          'active',
+          new Date(),
+          new Date()
+        ]);
+
+        console.log('Attempting to insert/update with values:', JSON.stringify(values, null, 2));
+
+        const placeholders = categoriesToInsert
+          .map((_, i) => `($${i * 8 + 1}, $${i * 8 + 2}, $${i * 8 + 3}, $${i * 8 + 4}, $${i * 8 + 5}, $${i * 8 + 6}, $${i * 8 + 7}, $${i * 8 + 8})`)
+          .join(',');
+
+        console.log('Using placeholders:', placeholders);
+
+        // Insert categories with ON CONFLICT clause for PostgreSQL
+        const query = `
+          WITH inserted_categories AS (
+            INSERT INTO categories (
+              cat_id, name, type, parent_id, description, status, created_at, updated_at
+            )
+            VALUES ${placeholders}
+            ON CONFLICT (cat_id) DO UPDATE SET
+              name = EXCLUDED.name,
+              type = EXCLUDED.type,
+              parent_id = EXCLUDED.parent_id,
+              description = EXCLUDED.description,
+              status = EXCLUDED.status,
+              updated_at = EXCLUDED.updated_at
+            RETURNING 
+              cat_id,
+              CASE 
+                WHEN xmax = 0 THEN true
+                ELSE false
+              END as is_insert
+          )
+          SELECT 
+            COUNT(*) as total,
+            COUNT(*) FILTER (WHERE is_insert) as inserted,
+            COUNT(*) FILTER (WHERE NOT is_insert) as updated
+          FROM inserted_categories`;
+
+        console.log('Executing query:', query);
+        
+        const result = await localConnection.query(query, values);
+        console.log('Query result:', result);
+
+        // Get the first result since query returns an array
+        const queryResult = Array.isArray(result) ? result[0] : result;
+
+        if (!queryResult || !queryResult.rows || !queryResult.rows[0]) {
+          console.error('Query failed to return results. Result:', queryResult);
+          throw new Error('Query did not return expected results');
+        }
+
+        const total = parseInt(queryResult.rows[0].total) || 0;
+        const inserted = parseInt(queryResult.rows[0].inserted) || 0;
+        const updated = parseInt(queryResult.rows[0].updated) || 0;
+
+        console.log(`Total: ${total}, Inserted: ${inserted}, Updated: ${updated}`);
+        
+        totalInserted += inserted;
+        totalUpdated += updated;
+
+        // Release the savepoint for this type
+        await localConnection.query(`RELEASE SAVEPOINT category_type_${type}`);
+
+        outputProgress({
+          status: "running",
+          operation: "Categories import",
+          message: `Imported ${inserted} (updated ${updated}) categories of type ${type}`,
+          current: totalInserted + totalUpdated,
+          total: categories.length,
+          elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
+        });
+      } catch (error) {
+        // Rollback to the savepoint for this type
+        await localConnection.query(`ROLLBACK TO SAVEPOINT category_type_${type}`);
+        throw error;
       }
-
-      console.log(
-        `Inserting ${categoriesToInsert.length} type ${type} categories`
-      );
-
-      const placeholders = categoriesToInsert
-        .map(() => "(?, ?, ?, ?, ?, ?, CURRENT_TIMESTAMP, CURRENT_TIMESTAMP)")
-        .join(",");
-
-      const values = categoriesToInsert.flatMap((cat) => [
-        cat.cat_id,
-        cat.name,
-        cat.type,
-        cat.parent_id,
-        cat.description,
-        "active",
-      ]);
-
-      // Insert categories and create relationships in one query to avoid race conditions
-      await localConnection.query(
-        `
-        INSERT INTO categories (cat_id, name, type, parent_id, description, status, created_at, updated_at)
-        VALUES ${placeholders}
-        ON DUPLICATE KEY UPDATE
-          name = VALUES(name),
-          type = VALUES(type),
-          parent_id = VALUES(parent_id),
-          description = VALUES(description),
-          status = VALUES(status),
-          updated_at = CURRENT_TIMESTAMP
-      `,
-        values
-      );
-
-      totalInserted += categoriesToInsert.length;
-      outputProgress({
-        status: "running",
-        operation: "Categories import",
-        current: totalInserted,
-        total: totalInserted,
-        elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
-      });
     }
 
-    // After all imports, if we skipped any categories, throw an error
-    if (skippedCategories.length > 0) {
-      const error = new Error(
-        "Categories import completed with errors - some categories were skipped due to missing parents"
-      );
-      error.skippedCategories = skippedCategories;
-      throw error;
-    }
+    // Commit the entire transaction - we'll do this even if we have skipped categories
+    await localConnection.query('COMMIT');
 
     outputProgress({
       status: "complete",
       operation: "Categories import completed",
-      current: totalInserted,
-      total: totalInserted,
+      current: totalInserted + totalUpdated,
+      total: totalInserted + totalUpdated,
       duration: formatElapsedTime((Date.now() - startTime) / 1000),
+      warnings: skippedCategories.length > 0 ? {
+        message: "Some categories were skipped due to missing parents",
+        skippedCategories
+      } : undefined
     });
 
     return {
       status: "complete",
-      totalImported: totalInserted
+      recordsAdded: totalInserted,
+      recordsUpdated: totalUpdated,
+      totalRecords: totalInserted + totalUpdated,
+      warnings: skippedCategories.length > 0 ? {
+        message: "Some categories were skipped due to missing parents",
+        skippedCategories
+      } : undefined
     };
   } catch (error) {
     console.error("Error importing categories:", error);
-    if (error.skippedCategories) {
-      console.error(
-        "Skipped categories:",
-        JSON.stringify(error.skippedCategories, null, 2)
-      );
+    
+    // Only rollback if we haven't committed yet
+    try {
+      await localConnection.query('ROLLBACK');
+    } catch (rollbackError) {
+      console.error("Error during rollback:", rollbackError);
     }
     
     outputProgress({
       status: "error",
       operation: "Categories import failed",
-      error: error.message,
-      skippedCategories: error.skippedCategories
+      error: error.message
     });
 
     throw error;

inventory-server/scripts/import/orders.js

@@ -2,7 +2,7 @@ const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate } =
 const { importMissingProducts, setupTemporaryTables, cleanupTemporaryTables, materializeCalculations } = require('./products');
 
 /**
- * Imports orders from a production MySQL database to a local MySQL database.
+ * Imports orders from a production MySQL database to a local PostgreSQL database.
  * It can run in two modes:
  *   1. Incremental update mode (default): Only fetch orders that have changed since the last sync time.
  *   2. Full update mode: Fetch all eligible orders within the last 5 years regardless of timestamp.
@@ -23,93 +23,18 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
   let importedCount = 0;
   let totalOrderItems = 0;
   let totalUniqueOrders = 0;
-
-  // Add a cumulative counter for processed orders before the loop
   let cumulativeProcessedOrders = 0;
 
   try {
-    // Clean up any existing temp tables first
-    await localConnection.query(`
-      DROP TEMPORARY TABLE IF EXISTS temp_order_items;
-      DROP TEMPORARY TABLE IF EXISTS temp_order_meta;
-      DROP TEMPORARY TABLE IF EXISTS temp_order_discounts;
-      DROP TEMPORARY TABLE IF EXISTS temp_order_taxes;
-      DROP TEMPORARY TABLE IF EXISTS temp_order_costs;
-    `);
-
-    // Create all temp tables with correct schema
-    await localConnection.query(`
-      CREATE TEMPORARY TABLE temp_order_items (
-        order_id INT UNSIGNED NOT NULL,
-        pid INT UNSIGNED NOT NULL,
-        SKU VARCHAR(50) NOT NULL,
-        price DECIMAL(10,2) NOT NULL,
-        quantity INT NOT NULL,
-        base_discount DECIMAL(10,2) DEFAULT 0,
-        PRIMARY KEY (order_id, pid)
-      ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-    `);
-
-    await localConnection.query(`
-      CREATE TEMPORARY TABLE temp_order_meta (
-        order_id INT UNSIGNED NOT NULL,
-        date DATE NOT NULL,
-        customer VARCHAR(100) NOT NULL,
-        customer_name VARCHAR(150) NOT NULL,
-        status INT,
-        canceled TINYINT(1),
-        summary_discount DECIMAL(10,2) DEFAULT 0.00,
-        summary_subtotal DECIMAL(10,2) DEFAULT 0.00,
-        PRIMARY KEY (order_id)
-      ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-    `);
-
-    await localConnection.query(`
-      CREATE TEMPORARY TABLE temp_order_discounts (
-        order_id INT UNSIGNED NOT NULL,
-        pid INT UNSIGNED NOT NULL,
-        discount DECIMAL(10,2) NOT NULL,
-        PRIMARY KEY (order_id, pid)
-      ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-    `);
-
-    await localConnection.query(`
-      CREATE TEMPORARY TABLE temp_order_taxes (
-        order_id INT UNSIGNED NOT NULL,
-        pid INT UNSIGNED NOT NULL,
-        tax DECIMAL(10,2) NOT NULL,
-        PRIMARY KEY (order_id, pid)
-      ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-    `);
-
-    await localConnection.query(`
-      CREATE TEMPORARY TABLE temp_order_costs (
-        order_id INT UNSIGNED NOT NULL,
-        pid INT UNSIGNED NOT NULL,
-        costeach DECIMAL(10,3) DEFAULT 0.000,
-        PRIMARY KEY (order_id, pid)
-      ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
-    `);
-
-    // Get column names from the local table
-    const [columns] = await localConnection.query(`
-      SELECT COLUMN_NAME 
-      FROM INFORMATION_SCHEMA.COLUMNS 
-      WHERE TABLE_NAME = 'orders'
-        AND COLUMN_NAME != 'updated'  -- Exclude the updated column
-      ORDER BY ORDINAL_POSITION
-    `);
-    const columnNames = columns.map(col => col.COLUMN_NAME);
-
     // Get last sync info
     const [syncInfo] = await localConnection.query(
       "SELECT last_sync_timestamp FROM sync_status WHERE table_name = 'orders'"
     );
-    const lastSyncTime = syncInfo?.[0]?.last_sync_timestamp || '1970-01-01';
+    const lastSyncTime = syncInfo?.rows?.[0]?.last_sync_timestamp || '1970-01-01';
 
     console.log('Orders: Using last sync time:', lastSyncTime);
 
-    // First get count of order items
+    // First get count of order items - Keep MySQL compatible for production
     const [[{ total }]] = await prodConnection.query(`
       SELECT COUNT(*) as total
       FROM order_items oi
@@ -141,12 +66,13 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
     totalOrderItems = total;
     console.log('Orders: Found changes:', totalOrderItems);
 
-    // Get order items in batches
+    // Get order items - Keep MySQL compatible for production
+    console.log('Orders: Starting MySQL query...');
     const [orderItems] = await prodConnection.query(`
       SELECT 
         oi.order_id,
-        oi.prod_pid as pid,
-        oi.prod_itemnumber as SKU,
+        oi.prod_pid,
+        COALESCE(NULLIF(TRIM(oi.prod_itemnumber), ''), 'NO-SKU') as SKU,
         oi.prod_price as price,
         oi.qty_ordered as quantity,
         COALESCE(oi.prod_price_reg - oi.prod_price, 0) as base_discount,
@@ -177,24 +103,78 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
         ` : ''}
     `, incrementalUpdate ? [lastSyncTime, lastSyncTime, lastSyncTime] : []);
 
-    console.log('Orders: Processing', orderItems.length, 'order items');
+    console.log('Orders: Found', orderItems.length, 'order items to process');
+
+    // Create tables in PostgreSQL for debugging
+    await localConnection.query(`
+      DROP TABLE IF EXISTS debug_order_items;
+      DROP TABLE IF EXISTS debug_order_meta;
+      DROP TABLE IF EXISTS debug_order_discounts;
+      DROP TABLE IF EXISTS debug_order_taxes;
+      DROP TABLE IF EXISTS debug_order_costs;
+
+      CREATE TABLE debug_order_items (
+        order_id INTEGER NOT NULL,
+        pid INTEGER NOT NULL,
+        SKU VARCHAR(50) NOT NULL,
+        price DECIMAL(10,2) NOT NULL,
+        quantity INTEGER NOT NULL,
+        base_discount DECIMAL(10,2) DEFAULT 0,
+        PRIMARY KEY (order_id, pid)
+      );
+
+      CREATE TABLE debug_order_meta (
+        order_id INTEGER NOT NULL,
+        date DATE NOT NULL,
+        customer VARCHAR(100) NOT NULL,
+        customer_name VARCHAR(150) NOT NULL,
+        status INTEGER,
+        canceled BOOLEAN,
+        summary_discount DECIMAL(10,2) DEFAULT 0.00,
+        summary_subtotal DECIMAL(10,2) DEFAULT 0.00,
+        PRIMARY KEY (order_id)
+      );
+
+      CREATE TABLE debug_order_discounts (
+        order_id INTEGER NOT NULL,
+        pid INTEGER NOT NULL,
+        discount DECIMAL(10,2) NOT NULL,
+        PRIMARY KEY (order_id, pid)
+      );
+
+      CREATE TABLE debug_order_taxes (
+        order_id INTEGER NOT NULL,
+        pid INTEGER NOT NULL,
+        tax DECIMAL(10,2) NOT NULL,
+        PRIMARY KEY (order_id, pid)
+      );
+
+      CREATE TABLE debug_order_costs (
+        order_id INTEGER NOT NULL,
+        pid INTEGER NOT NULL,
+        costeach DECIMAL(10,3) DEFAULT 0.000,
+        PRIMARY KEY (order_id, pid)
+      );
+    `);
 
     // Insert order items in batches
     for (let i = 0; i < orderItems.length; i += 5000) {
       const batch = orderItems.slice(i, Math.min(i + 5000, orderItems.length));
-      const placeholders = batch.map(() => "(?, ?, ?, ?, ?, ?)").join(",");
+      const placeholders = batch.map((_, idx) => 
+        `($${idx * 6 + 1}, $${idx * 6 + 2}, $${idx * 6 + 3}, $${idx * 6 + 4}, $${idx * 6 + 5}, $${idx * 6 + 6})`
+      ).join(",");
       const values = batch.flatMap(item => [
-        item.order_id, item.pid, item.SKU, item.price, item.quantity, item.base_discount
+        item.order_id, item.prod_pid, item.SKU, item.price, item.quantity, item.base_discount
       ]);
 
       await localConnection.query(`
-        INSERT INTO temp_order_items (order_id, pid, SKU, price, quantity, base_discount)
+        INSERT INTO debug_order_items (order_id, pid, SKU, price, quantity, base_discount)
         VALUES ${placeholders}
-        ON DUPLICATE KEY UPDATE
-          SKU = VALUES(SKU),
-          price = VALUES(price),
-          quantity = VALUES(quantity),
-          base_discount = VALUES(base_discount)
+        ON CONFLICT (order_id, pid) DO UPDATE SET
+          SKU = EXCLUDED.SKU,
+          price = EXCLUDED.price,
+          quantity = EXCLUDED.quantity,
+          base_discount = EXCLUDED.base_discount
       `, values);
 
       processedCount = i + batch.length;
@@ -203,24 +183,26 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
         operation: "Orders import",
         message: `Loading order items: ${processedCount} of ${totalOrderItems}`,
         current: processedCount,
-        total: totalOrderItems
+        total: totalOrderItems,
+        elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
+        remaining: estimateRemaining(startTime, processedCount, totalOrderItems),
+        rate: calculateRate(startTime, processedCount)
       });
     }
 
     // Get unique order IDs
     const orderIds = [...new Set(orderItems.map(item => item.order_id))];
     totalUniqueOrders = orderIds.length;
-    console.log('Total unique order IDs:', totalUniqueOrders);
+    console.log('Orders: Processing', totalUniqueOrders, 'unique orders');
 
     // Reset processed count for order processing phase
     processedCount = 0;
 
-    // Get order metadata in batches
-    for (let i = 0; i < orderIds.length; i += 5000) {
-      const batchIds = orderIds.slice(i, i + 5000);
-      console.log(`Processing batch ${i/5000 + 1}, size: ${batchIds.length}`);
-      console.log('Sample of batch IDs:', batchIds.slice(0, 5));
-      
+    // Process metadata, discounts, taxes, and costs in parallel
+    const METADATA_BATCH_SIZE = 2000;
+    const PG_BATCH_SIZE = 200;
+    
+    const processMetadataBatch = async (batchIds) => {
       const [orders] = await prodConnection.query(`
         SELECT 
           o.order_id,
@@ -235,64 +217,46 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
         LEFT JOIN users u ON o.order_cid = u.cid
         WHERE o.order_id IN (?)
       `, [batchIds]);
-      
-      console.log(`Retrieved ${orders.length} orders for ${batchIds.length} IDs`);
-      const duplicates = orders.filter((order, index, self) => 
-        self.findIndex(o => o.order_id === order.order_id) !== index
-      );
-      if (duplicates.length > 0) {
-        console.log('Found duplicates:', duplicates);
+
+      // Process in sub-batches for PostgreSQL
+      for (let j = 0; j < orders.length; j += PG_BATCH_SIZE) {
+        const subBatch = orders.slice(j, j + PG_BATCH_SIZE);
+        if (subBatch.length === 0) continue;
+
+        const placeholders = subBatch.map((_, idx) => 
+          `($${idx * 8 + 1}, $${idx * 8 + 2}, $${idx * 8 + 3}, $${idx * 8 + 4}, $${idx * 8 + 5}, $${idx * 8 + 6}, $${idx * 8 + 7}, $${idx * 8 + 8})`
+        ).join(",");
+        
+        const values = subBatch.flatMap(order => [
+          order.order_id,
+          order.date,
+          order.customer,
+          order.customer_name || '',
+          order.status,
+          order.canceled,
+          order.summary_discount || 0,
+          order.summary_subtotal || 0
+        ]);
+
+        await localConnection.query(`
+          INSERT INTO debug_order_meta (
+            order_id, date, customer, customer_name, status, canceled,
+            summary_discount, summary_subtotal
+          )
+          VALUES ${placeholders}
+          ON CONFLICT (order_id) DO UPDATE SET
+            date = EXCLUDED.date,
+            customer = EXCLUDED.customer,
+            customer_name = EXCLUDED.customer_name,
+            status = EXCLUDED.status,
+            canceled = EXCLUDED.canceled,
+            summary_discount = EXCLUDED.summary_discount,
+            summary_subtotal = EXCLUDED.summary_subtotal
+        `, values);
       }
+    };
 
-      const placeholders = orders.map(() => "(?, ?, ?, ?, ?, ?, ?, ?)").join(",");
-      const values = orders.flatMap(order => [
-        order.order_id, 
-        order.date, 
-        order.customer, 
-        order.customer_name, 
-        order.status, 
-        order.canceled,
-        order.summary_discount,
-        order.summary_subtotal
-      ]);
-
-      await localConnection.query(`
-        INSERT INTO temp_order_meta (
-          order_id, 
-          date, 
-          customer, 
-          customer_name, 
-          status, 
-          canceled,
-          summary_discount,
-          summary_subtotal
-        ) VALUES ${placeholders}
-        ON DUPLICATE KEY UPDATE
-          date = VALUES(date),
-          customer = VALUES(customer),
-          customer_name = VALUES(customer_name),
-          status = VALUES(status),
-          canceled = VALUES(canceled),
-          summary_discount = VALUES(summary_discount),
-          summary_subtotal = VALUES(summary_subtotal)
-      `, values);
-
-      processedCount = i + orders.length;
-      outputProgress({
-        status: "running",
-        operation: "Orders import",
-        message: `Loading order metadata: ${processedCount} of ${totalUniqueOrders}`,
-        current: processedCount,
-        total: totalUniqueOrders
-      });
-    }
-
-    // Reset processed count for final phase
-    processedCount = 0;
-
-    // Get promotional discounts in batches
-    for (let i = 0; i < orderIds.length; i += 5000) {
-      const batchIds = orderIds.slice(i, i + 5000);
+    const processDiscountsBatch = async (batchIds) => {
       const [discounts] = await prodConnection.query(`
         SELECT order_id, pid, SUM(amount) as discount
         FROM order_discount_items
@@ -300,313 +264,296 @@ async function importOrders(prodConnection, localConnection, incrementalUpdate =
         GROUP BY order_id, pid
       `, [batchIds]);
 
-      if (discounts.length > 0) {
-        const placeholders = discounts.map(() => "(?, ?, ?)").join(",");
-        const values = discounts.flatMap(d => [d.order_id, d.pid, d.discount]);
+      if (discounts.length === 0) return;
+
+      for (let j = 0; j < discounts.length; j += PG_BATCH_SIZE) {
+        const subBatch = discounts.slice(j, j + PG_BATCH_SIZE);
+        if (subBatch.length === 0) continue;
+
+        const placeholders = subBatch.map((_, idx) => 
+          `($${idx * 3 + 1}, $${idx * 3 + 2}, $${idx * 3 + 3})`
+        ).join(",");
+        
+        const values = subBatch.flatMap(d => [
+          d.order_id,
+          d.pid,
+          d.discount || 0
+        ]);
 
         await localConnection.query(`
-          INSERT INTO temp_order_discounts VALUES ${placeholders}
-          ON DUPLICATE KEY UPDATE
-            discount = VALUES(discount)
+          INSERT INTO debug_order_discounts (order_id, pid, discount)
+          VALUES ${placeholders}
+          ON CONFLICT (order_id, pid) DO UPDATE SET
+            discount = EXCLUDED.discount
         `, values);
       }
-    }
+    };
 
-    // Get tax information in batches
-    for (let i = 0; i < orderIds.length; i += 5000) {
-      const batchIds = orderIds.slice(i, i + 5000);
+    const processTaxesBatch = async (batchIds) => {
+      // Optimized tax query to avoid subquery
       const [taxes] = await prodConnection.query(`
-        SELECT DISTINCT
-          oti.order_id,
-          otip.pid,
-          otip.item_taxes_to_collect as tax
-        FROM order_tax_info oti
-        JOIN (
-          SELECT order_id, MAX(stamp) as max_stamp
+        SELECT oti.order_id, otip.pid, otip.item_taxes_to_collect as tax
+        FROM (
+          SELECT order_id, MAX(taxinfo_id) as latest_taxinfo_id
           FROM order_tax_info
           WHERE order_id IN (?)
           GROUP BY order_id
-        ) latest ON oti.order_id = latest.order_id AND oti.stamp = latest.max_stamp
+        ) latest_info
+        JOIN order_tax_info oti ON oti.order_id = latest_info.order_id 
+          AND oti.taxinfo_id = latest_info.latest_taxinfo_id
         JOIN order_tax_info_products otip ON oti.taxinfo_id = otip.taxinfo_id
       `, [batchIds]);
 
-      if (taxes.length > 0) {
-        // Remove any duplicates before inserting
-        const uniqueTaxes = new Map();
-        taxes.forEach(t => {
-          const key = `${t.order_id}-${t.pid}`;
-          uniqueTaxes.set(key, t);
-        });
+      if (taxes.length === 0) return;
 
-        const values = Array.from(uniqueTaxes.values()).flatMap(t => [t.order_id, t.pid, t.tax]);
-        if (values.length > 0) {
-          const placeholders = Array(uniqueTaxes.size).fill("(?, ?, ?)").join(",");
-          await localConnection.query(`
-            INSERT INTO temp_order_taxes VALUES ${placeholders}
-            ON DUPLICATE KEY UPDATE tax = VALUES(tax)
-          `, values);
-        }
-      }
-    }
+      for (let j = 0; j < taxes.length; j += PG_BATCH_SIZE) {
+        const subBatch = taxes.slice(j, j + PG_BATCH_SIZE);
+        if (subBatch.length === 0) continue;
 
-    // Get costeach values in batches
-    for (let i = 0; i < orderIds.length; i += 5000) {
-      const batchIds = orderIds.slice(i, i + 5000);
-      const [costs] = await prodConnection.query(`
-        SELECT 
-          oc.orderid as order_id, 
-          oc.pid,
-          COALESCE(
-            oc.costeach,
-            (SELECT pi.costeach 
-             FROM product_inventory pi 
-             WHERE pi.pid = oc.pid 
-             AND pi.daterec <= o.date_placed
-             ORDER BY pi.daterec DESC LIMIT 1)
-          ) as costeach
-        FROM order_costs oc
-        JOIN _order o ON oc.orderid = o.order_id
-        WHERE oc.orderid IN (?)
-      `, [batchIds]);
+        const placeholders = subBatch.map((_, idx) => 
+          `($${idx * 3 + 1}, $${idx * 3 + 2}, $${idx * 3 + 3})`
+        ).join(",");
+        
+        const values = subBatch.flatMap(t => [
+          t.order_id,
+          t.pid,
+          t.tax || 0
+        ]);
 
-      if (costs.length > 0) {
-        const placeholders = costs.map(() => '(?, ?, ?)').join(",");
-        const values = costs.flatMap(c => [c.order_id, c.pid, c.costeach || 0]);
         await localConnection.query(`
-          INSERT INTO temp_order_costs (order_id, pid, costeach)
+          INSERT INTO debug_order_taxes (order_id, pid, tax)
           VALUES ${placeholders}
-          ON DUPLICATE KEY UPDATE costeach = VALUES(costeach)
+          ON CONFLICT (order_id, pid) DO UPDATE SET
+            tax = EXCLUDED.tax
         `, values);
       }
-    }
+    };
 
-    // Now combine all the data and insert into orders table
-    // Pre-check all products at once instead of per batch
-    const allOrderPids = [...new Set(orderItems.map(item => item.pid))];
-    const [existingProducts] = allOrderPids.length > 0 ? await localConnection.query(
-      "SELECT pid FROM products WHERE pid IN (?)",
-      [allOrderPids]
-    ) : [[]];
-    const existingPids = new Set(existingProducts.map(p => p.pid));
-
-    // Process in larger batches
-    for (let i = 0; i < orderIds.length; i += 5000) {
-      const batchIds = orderIds.slice(i, i + 5000);
-
-      // Get combined data for this batch
-      const [orders] = await localConnection.query(`
+    const processCostsBatch = async (batchIds) => {
+      const [costs] = await prodConnection.query(`
         SELECT 
-          oi.order_id as order_number,
-          oi.pid,
-          oi.SKU,
-          om.date,
-          oi.price,
-          oi.quantity,
-          oi.base_discount + COALESCE(od.discount, 0) + 
-          CASE 
-            WHEN om.summary_discount > 0 THEN 
-              ROUND((om.summary_discount * (oi.price * oi.quantity)) / 
-                NULLIF(om.summary_subtotal, 0), 2)
-            ELSE 0 
-          END as discount,
-          COALESCE(ot.tax, 0) as tax,
-          0 as tax_included,
-          0 as shipping,
-          om.customer,
-          om.customer_name,
-          om.status,
-          om.canceled,
-          COALESCE(tc.costeach, 0) as costeach
-        FROM temp_order_items oi
-        JOIN temp_order_meta om ON oi.order_id = om.order_id
-        LEFT JOIN temp_order_discounts od ON oi.order_id = od.order_id AND oi.pid = od.pid
-        LEFT JOIN temp_order_taxes ot ON oi.order_id = ot.order_id AND oi.pid = ot.pid
-        LEFT JOIN temp_order_costs tc ON oi.order_id = tc.order_id AND oi.pid = tc.pid
-        WHERE oi.order_id IN (?)
+          oc.orderid as order_id,
+          oc.pid,
+          oc.costeach
+        FROM order_costs oc
+        WHERE oc.orderid IN (?)
+          AND oc.pending = 0
       `, [batchIds]);
 
-      // Filter orders and track missing products - do this in a single pass
-      const validOrders = [];
-      const values = [];
-      const processedOrderItems = new Set(); // Track unique order items
-      const processedOrders = new Set(); // Track unique orders
-      
-      for (const order of orders) {
-        if (!existingPids.has(order.pid)) {
-          missingProducts.add(order.pid);
-          skippedOrders.add(order.order_number);
-          continue;
-        }
-        validOrders.push(order);
-        values.push(...columnNames.map(col => order[col] ?? null));
-        processedOrderItems.add(`${order.order_number}-${order.pid}`);
-        processedOrders.add(order.order_number);
-      }
+      if (costs.length === 0) return;
 
-      if (validOrders.length > 0) {
-        // Pre-compute the placeholders string once
-        const singlePlaceholder = `(${columnNames.map(() => "?").join(",")})`;
-        const placeholders = Array(validOrders.length).fill(singlePlaceholder).join(",");
+      for (let j = 0; j < costs.length; j += PG_BATCH_SIZE) {
+        const subBatch = costs.slice(j, j + PG_BATCH_SIZE);
+        if (subBatch.length === 0) continue;
+
+        const placeholders = subBatch.map((_, idx) => 
+          `($${idx * 3 + 1}, $${idx * 3 + 2}, $${idx * 3 + 3})`
+        ).join(",");
         
-        const result = await localConnection.query(`
-          INSERT INTO orders (${columnNames.join(",")})
+        const values = subBatch.flatMap(c => [
+          c.order_id,
+          c.pid,
+          c.costeach || 0
+        ]);
+
+        await localConnection.query(`
+          INSERT INTO debug_order_costs (order_id, pid, costeach)
           VALUES ${placeholders}
-          ON DUPLICATE KEY UPDATE
-            SKU = VALUES(SKU),
-            date = VALUES(date),
-            price = VALUES(price),
-            quantity = VALUES(quantity),
-            discount = VALUES(discount),
-            tax = VALUES(tax),
-            tax_included = VALUES(tax_included),
-            shipping = VALUES(shipping),
-            customer = VALUES(customer),
-            customer_name = VALUES(customer_name),
-            status = VALUES(status),
-            canceled = VALUES(canceled),
-            costeach = VALUES(costeach)
-        `, validOrders.map(o => columnNames.map(col => o[col] ?? null)).flat());
-        
-        const affectedRows = result[0].affectedRows;
-        const updates = Math.floor(affectedRows / 2);
-        const inserts = affectedRows - (updates * 2);
-        
-        recordsAdded += inserts;
-        recordsUpdated += updates;
-        importedCount += processedOrderItems.size; // Count unique order items processed
+          ON CONFLICT (order_id, pid) DO UPDATE SET
+            costeach = EXCLUDED.costeach
+        `, values);
       }
+    };
 
-      // Update progress based on unique orders processed
-      cumulativeProcessedOrders += processedOrders.size;
+    // Process all data types in parallel for each batch
+    for (let i = 0; i < orderIds.length; i += METADATA_BATCH_SIZE) {
+      const batchIds = orderIds.slice(i, i + METADATA_BATCH_SIZE);
+      
+      await Promise.all([
+        processMetadataBatch(batchIds),
+        processDiscountsBatch(batchIds),
+        processTaxesBatch(batchIds),
+        processCostsBatch(batchIds)
+      ]);
+
+      processedCount = i + batchIds.length;
       outputProgress({
         status: "running",
         operation: "Orders import",
-        message: `Imported ${importedCount} order items (${cumulativeProcessedOrders} of ${totalUniqueOrders} orders processed)`,
-        current: cumulativeProcessedOrders,
+        message: `Loading order data: ${processedCount} of ${totalUniqueOrders}`,
+        current: processedCount,
         total: totalUniqueOrders,
         elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
-        remaining: estimateRemaining(startTime, cumulativeProcessedOrders, totalUniqueOrders),
-        rate: calculateRate(startTime, cumulativeProcessedOrders)
+        remaining: estimateRemaining(startTime, processedCount, totalUniqueOrders),
+        rate: calculateRate(startTime, processedCount)
       });
     }
 
-    // Now try to import any orders that were skipped due to missing products
-    if (skippedOrders.size > 0) {
-      try {
-        outputProgress({
-          status: "running",
-          operation: "Orders import",
-          message: `Retrying import of ${skippedOrders.size} orders with previously missing products`,
-        });
+    // Pre-check all products at once
+    const allOrderPids = [...new Set(orderItems.map(item => item.prod_pid))];
+    console.log('Orders: Checking', allOrderPids.length, 'unique products');
+    
+    const [existingProducts] = allOrderPids.length > 0 ? await localConnection.query(
+      "SELECT pid FROM products WHERE pid = ANY($1::bigint[])",
+      [allOrderPids]
+    ) : [[]];
+    
+    const existingPids = new Set(existingProducts.rows.map(p => p.pid));
+    
+    // Process in smaller batches
+    for (let i = 0; i < orderIds.length; i += 1000) {
+      const batchIds = orderIds.slice(i, i + 1000);
 
-        // Get the orders that were skipped
-        const [skippedProdOrders] = await localConnection.query(`
-          SELECT DISTINCT
+      // Get combined data for this batch in sub-batches
+      const PG_BATCH_SIZE = 100; // Process 100 records at a time
+      for (let j = 0; j < batchIds.length; j += PG_BATCH_SIZE) {
+        const subBatchIds = batchIds.slice(j, j + PG_BATCH_SIZE);
+        
+        const [orders] = await localConnection.query(`
+          WITH order_totals AS (
+            SELECT 
+              oi.order_id,
+              oi.pid,
+              SUM(COALESCE(od.discount, 0)) as promo_discount,
+              COALESCE(ot.tax, 0) as total_tax,
+              COALESCE(oi.price * 0.5, 0) as costeach
+            FROM debug_order_items oi
+            LEFT JOIN debug_order_discounts od ON oi.order_id = od.order_id AND oi.pid = od.pid
+            LEFT JOIN debug_order_taxes ot ON oi.order_id = ot.order_id AND oi.pid = ot.pid
+            GROUP BY oi.order_id, oi.pid, ot.tax
+          )
+          SELECT 
             oi.order_id as order_number,
-            oi.pid,
-            oi.SKU,
+            oi.pid::bigint as pid,
+            oi.SKU as sku,
             om.date,
             oi.price,
             oi.quantity,
-            oi.base_discount + COALESCE(od.discount, 0) + 
-            CASE 
-              WHEN o.summary_discount > 0 THEN 
-                ROUND((o.summary_discount * (oi.price * oi.quantity)) / 
-                  NULLIF(o.summary_subtotal, 0), 2)
+            (oi.base_discount + 
+             COALESCE(ot.promo_discount, 0) + 
+             CASE 
+              WHEN om.summary_discount > 0 AND om.summary_subtotal > 0 THEN 
+                ROUND((om.summary_discount * (oi.price * oi.quantity)) / NULLIF(om.summary_subtotal, 0), 2)
               ELSE 0 
-            END as discount,
-            COALESCE(ot.tax, 0) as tax,
-            0 as tax_included,
+             END)::DECIMAL(10,2) as discount,
+            COALESCE(ot.total_tax, 0)::DECIMAL(10,2) as tax,
+            false as tax_included,
             0 as shipping,
             om.customer,
             om.customer_name,
             om.status,
             om.canceled,
-            COALESCE(tc.costeach, 0) as costeach
-          FROM temp_order_items oi
-          JOIN temp_order_meta om ON oi.order_id = om.order_id
-          LEFT JOIN _order o ON oi.order_id = o.order_id
-          LEFT JOIN temp_order_discounts od ON oi.order_id = od.order_id AND oi.pid = od.pid
-          LEFT JOIN temp_order_taxes ot ON oi.order_id = ot.order_id AND oi.pid = ot.pid
-          LEFT JOIN temp_order_costs tc ON oi.order_id = tc.order_id AND oi.pid = tc.pid
-          WHERE oi.order_id IN (?)
-        `, [Array.from(skippedOrders)]);
+            COALESCE(ot.costeach, oi.price * 0.5)::DECIMAL(10,3) as costeach
+          FROM (
+            SELECT DISTINCT ON (order_id, pid)
+              order_id, pid, SKU, price, quantity, base_discount
+            FROM debug_order_items
+            WHERE order_id = ANY($1)
+            ORDER BY order_id, pid
+          ) oi
+          JOIN debug_order_meta om ON oi.order_id = om.order_id
+          LEFT JOIN order_totals ot ON oi.order_id = ot.order_id AND oi.pid = ot.pid
+          ORDER BY oi.order_id, oi.pid
+        `, [subBatchIds]);
 
-        // Check which products exist now
-        const skippedPids = [...new Set(skippedProdOrders.map(o => o.pid))];
-        const [existingProducts] = skippedPids.length > 0 ? await localConnection.query(
-          "SELECT pid FROM products WHERE pid IN (?)",
-          [skippedPids]
-        ) : [[]];
-        const existingPids = new Set(existingProducts.map(p => p.pid));
-
-        // Filter orders that can now be imported
-        const validOrders = skippedProdOrders.filter(order => existingPids.has(order.pid));
-        const retryOrderItems = new Set(); // Track unique order items in retry
-
-        if (validOrders.length > 0) {
-          const placeholders = validOrders.map(() => `(${columnNames.map(() => "?").join(", ")})`).join(",");
-          const values = validOrders.map(o => columnNames.map(col => o[col] ?? null)).flat();
-
-          const result = await localConnection.query(`
-            INSERT INTO orders (${columnNames.join(", ")})
-            VALUES ${placeholders}
-            ON DUPLICATE KEY UPDATE
-              SKU = VALUES(SKU),
-              date = VALUES(date),
-              price = VALUES(price),
-              quantity = VALUES(quantity),
-              discount = VALUES(discount),
-              tax = VALUES(tax),
-              tax_included = VALUES(tax_included),
-              shipping = VALUES(shipping),
-              customer = VALUES(customer),
-              customer_name = VALUES(customer_name),
-              status = VALUES(status),
-              canceled = VALUES(canceled),
-              costeach = VALUES(costeach)
-          `, values);
-
-          const affectedRows = result[0].affectedRows;
-          const updates = Math.floor(affectedRows / 2);
-          const inserts = affectedRows - (updates * 2);
-          
-          // Track unique order items
-          validOrders.forEach(order => {
-            retryOrderItems.add(`${order.order_number}-${order.pid}`);
-          });
-          
-          outputProgress({
-            status: "running",
-            operation: "Orders import",
-            message: `Successfully imported ${retryOrderItems.size} previously skipped order items`,
-          });
-
-          // Update the main counters
-          recordsAdded += inserts;
-          recordsUpdated += updates;
-          importedCount += retryOrderItems.size;
+        // Filter orders and track missing products
+        const validOrders = [];
+        const processedOrderItems = new Set();
+        const processedOrders = new Set();
+        
+        for (const order of orders.rows) {
+          if (!existingPids.has(order.pid)) {
+            missingProducts.add(order.pid);
+            skippedOrders.add(order.order_number);
+            continue;
+          }
+          validOrders.push(order);
+          processedOrderItems.add(`${order.order_number}-${order.pid}`);
+          processedOrders.add(order.order_number);
         }
-      } catch (error) {
-        console.warn('Warning: Failed to retry skipped orders:', error.message);
-        console.warn(`Skipped ${skippedOrders.size} orders due to ${missingProducts.size} missing products`);
+
+        // Process valid orders in smaller sub-batches
+        const FINAL_BATCH_SIZE = 50;
+        for (let k = 0; k < validOrders.length; k += FINAL_BATCH_SIZE) {
+          const subBatch = validOrders.slice(k, k + FINAL_BATCH_SIZE);
+          
+          const placeholders = subBatch.map((_, idx) => {
+            const base = idx * 14;  // 14 columns (removed updated)
+            return `($${base + 1}, $${base + 2}, $${base + 3}, $${base + 4}, $${base + 5}, $${base + 6}, $${base + 7}, $${base + 8}, $${base + 9}, $${base + 10}, $${base + 11}, $${base + 12}, $${base + 13}, $${base + 14})`;
+          }).join(',');
+
+          const batchValues = subBatch.flatMap(o => [
+            o.order_number,
+            o.pid,
+            o.sku || 'NO-SKU',
+            o.date,
+            o.price,
+            o.quantity,
+            o.discount,
+            o.tax,
+            o.tax_included,
+            o.shipping,
+            o.customer,
+            o.customer_name,
+            o.status,
+            o.canceled
+          ]);
+
+          const [result] = await localConnection.query(`
+            WITH inserted_orders AS (
+              INSERT INTO orders (
+                order_number, pid, sku, date, price, quantity, discount,
+                tax, tax_included, shipping, customer, customer_name,
+                status, canceled
+              )
+              VALUES ${placeholders}
+              ON CONFLICT (order_number, pid) DO UPDATE SET
+                sku = EXCLUDED.sku,
+                date = EXCLUDED.date,
+                price = EXCLUDED.price,
+                quantity = EXCLUDED.quantity,
+                discount = EXCLUDED.discount,
+                tax = EXCLUDED.tax,
+                tax_included = EXCLUDED.tax_included,
+                shipping = EXCLUDED.shipping,
+                customer = EXCLUDED.customer,
+                customer_name = EXCLUDED.customer_name,
+                status = EXCLUDED.status,
+                canceled = EXCLUDED.canceled
+              RETURNING xmax = 0 as inserted
+            )
+            SELECT 
+              COUNT(*) FILTER (WHERE inserted) as inserted,
+              COUNT(*) FILTER (WHERE NOT inserted) as updated
+            FROM inserted_orders
+          `, batchValues);
+          
+          const { inserted, updated } = result.rows[0];
+          recordsAdded += inserted;
+          recordsUpdated += updated;
+          importedCount += subBatch.length;
+        }
+
+        cumulativeProcessedOrders += processedOrders.size;
+        outputProgress({
+          status: "running",
+          operation: "Orders import",
+          message: `Importing orders: ${cumulativeProcessedOrders} of ${totalUniqueOrders}`,
+          current: cumulativeProcessedOrders,
+          total: totalUniqueOrders,
+          elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
+          remaining: estimateRemaining(startTime, cumulativeProcessedOrders, totalUniqueOrders),
+          rate: calculateRate(startTime, cumulativeProcessedOrders)
+        });
       }
     }
 
-    // Clean up temporary tables after ALL processing is complete
-    await localConnection.query(`
-      DROP TEMPORARY TABLE IF EXISTS temp_order_items;
-      DROP TEMPORARY TABLE IF EXISTS temp_order_meta;
-      DROP TEMPORARY TABLE IF EXISTS temp_order_discounts;
-      DROP TEMPORARY TABLE IF EXISTS temp_order_taxes;
-      DROP TEMPORARY TABLE IF EXISTS temp_order_costs;
-    `);
-
-    // Only update sync status if we get here (no errors thrown)
+    // Update sync status
     await localConnection.query(`
       INSERT INTO sync_status (table_name, last_sync_timestamp)
       VALUES ('orders', NOW())
-      ON DUPLICATE KEY UPDATE last_sync_timestamp = NOW()
+      ON CONFLICT (table_name) DO UPDATE SET
+        last_sync_timestamp = NOW()
     `);
 
     return {

inventory-server/scripts/import/purchase-orders.js

@@ -10,22 +10,42 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
     const [syncInfo] = await localConnection.query(
       "SELECT last_sync_timestamp FROM sync_status WHERE table_name = 'purchase_orders'"
     );
-    const lastSyncTime = syncInfo?.[0]?.last_sync_timestamp || '1970-01-01';
+    const lastSyncTime = syncInfo?.rows?.[0]?.last_sync_timestamp || '1970-01-01';
 
     console.log('Purchase Orders: Using last sync time:', lastSyncTime);
 
-    // Insert temporary table creation query for purchase orders
+    // Create temporary tables with PostgreSQL syntax
     await localConnection.query(`
-      CREATE TABLE IF NOT EXISTS temp_purchase_orders (
-        po_id INT UNSIGNED NOT NULL,
-        pid INT UNSIGNED NOT NULL,
+      DROP TABLE IF EXISTS temp_purchase_orders;
+      DROP TABLE IF EXISTS temp_po_receivings;
+
+      CREATE TEMP TABLE temp_purchase_orders (
+        po_id INTEGER NOT NULL,
+        pid INTEGER NOT NULL,
+        sku VARCHAR(50),
+        name VARCHAR(255),
         vendor VARCHAR(255),
-        date DATE,
-        expected_date DATE,
-        status INT,
+        date TIMESTAMP WITH TIME ZONE,
+        expected_date TIMESTAMP WITH TIME ZONE,
+        status INTEGER,
         notes TEXT,
+        ordered INTEGER,
+        cost_price DECIMAL(10,3),
         PRIMARY KEY (po_id, pid)
-      ) ENGINE=InnoDB DEFAULT CHARSET=utf8;
+      );
+
+      CREATE TEMP TABLE temp_po_receivings (
+        po_id INTEGER,
+        pid INTEGER NOT NULL,
+        receiving_id INTEGER NOT NULL,
+        qty_each INTEGER,
+        cost_each DECIMAL(10,3),
+        received_date TIMESTAMP WITH TIME ZONE,
+        received_by INTEGER,
+        received_by_name VARCHAR(255),
+        is_alt_po INTEGER,
+        PRIMARY KEY (receiving_id, pid)
+      );
     `);
 
     outputProgress({
@@ -33,8 +53,8 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
       status: "running",
     });
 
-    // Get column names first
-    const [columns] = await localConnection.query(`
+    // Get column names - Keep MySQL compatible for production
+    const [columns] = await prodConnection.query(`
       SELECT COLUMN_NAME 
       FROM INFORMATION_SCHEMA.COLUMNS 
       WHERE TABLE_NAME = 'purchase_orders'
@@ -60,7 +80,7 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
       ? [lastSyncTime, lastSyncTime, lastSyncTime, lastSyncTime, lastSyncTime, lastSyncTime, lastSyncTime, lastSyncTime]
       : [];
 
-    // First get all relevant PO IDs with basic info
+    // First get all relevant PO IDs with basic info - Keep MySQL compatible for production
     const [[{ total }]] = await prodConnection.query(`
       SELECT COUNT(*) as total
       FROM (
@@ -99,6 +119,7 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
 
     console.log('Purchase Orders: Found changes:', total);
 
+    // Get PO list - Keep MySQL compatible for production
     const [poList] = await prodConnection.query(`
       SELECT DISTINCT 
         COALESCE(p.po_id, r.receiving_id) as po_id,
@@ -109,12 +130,12 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
         ) as vendor,
         CASE 
           WHEN p.po_id IS NOT NULL THEN 
-            DATE(COALESCE(
+            COALESCE(
               NULLIF(p.date_ordered, '0000-00-00 00:00:00'),
               p.date_created
-            ))
+            )
           WHEN r.receiving_id IS NOT NULL THEN
-            DATE(r.date_created)
+            r.date_created
         END as date,
         CASE 
           WHEN p.date_estin = '0000-00-00' THEN NULL
@@ -185,14 +206,14 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
       const batch = poList.slice(i, Math.min(i + BATCH_SIZE, poList.length));
       const poIds = batch.map(po => po.po_id);
 
-      // Get all products for these POs in one query
+      // Get all products for these POs in one query - Keep MySQL compatible for production
       const [poProducts] = await prodConnection.query(`
         SELECT 
           pop.po_id,
           pop.pid,
           pr.itemnumber as sku,
           pr.description as name,
-          pop.cost_each,
+          pop.cost_each as cost_price,
           pop.qty_each as ordered
         FROM po_products pop
         USE INDEX (PRIMARY)
@@ -232,317 +253,397 @@ async function importPurchaseOrders(prodConnection, localConnection, incremental
           ORDER BY r.po_id, rp.pid, rp.received_date
         `, [batchPoIds, productPids]);
 
-        // Create maps for this sub-batch
-        const poProductMap = new Map();
-        productBatch.forEach(product => {
-          const key = `${product.po_id}-${product.pid}`;
-          poProductMap.set(key, product);
-        });
-
-        const receivingMap = new Map();
-        const altReceivingMap = new Map();
-        const noPOReceivingMap = new Map();
-        
-        receivings.forEach(receiving => {
-          const key = `${receiving.po_id}-${receiving.pid}`;
-          if (receiving.is_alt_po === 2) {
-            // No PO
-            if (!noPOReceivingMap.has(receiving.pid)) {
-              noPOReceivingMap.set(receiving.pid, []);
-            }
-            noPOReceivingMap.get(receiving.pid).push(receiving);
-          } else if (receiving.is_alt_po === 1) {
-            // Different PO
-            if (!altReceivingMap.has(receiving.pid)) {
-              altReceivingMap.set(receiving.pid, []);
-            }
-            altReceivingMap.get(receiving.pid).push(receiving);
-          } else {
-            // Original PO
-            if (!receivingMap.has(key)) {
-              receivingMap.set(key, []);
-            }
-            receivingMap.get(key).push(receiving);
-          }
-        });
-
-        // Verify PIDs exist
-        const [existingPids] = await localConnection.query(
-          'SELECT pid FROM products WHERE pid IN (?)',
-          [productPids]
-        );
-        const validPids = new Set(existingPids.map(p => p.pid));
-
-        // First check which PO lines already exist and get their current values
-        const poLines = Array.from(poProductMap.values())
-          .filter(p => validPids.has(p.pid))
-          .map(p => [p.po_id, p.pid]);
-
-        const [existingPOs] = await localConnection.query(
-          `SELECT ${columnNames.join(',')} FROM purchase_orders WHERE (po_id, pid) IN (${poLines.map(() => "(?,?)").join(",")})`,
-          poLines.flat()
-        );
-        const existingPOMap = new Map(
-          existingPOs.map(po => [`${po.po_id}-${po.pid}`, po])
-        );
-
-        // Split into inserts and updates
-        const insertsAndUpdates = { inserts: [], updates: [] };
-        let batchProcessed = 0;
-
-        for (const po of batch) {
-          const poProducts = Array.from(poProductMap.values())
-            .filter(p => p.po_id === po.po_id && validPids.has(p.pid));
-
-          for (const product of poProducts) {
-            const key = `${po.po_id}-${product.pid}`;
-            const receivingHistory = receivingMap.get(key) || [];
-            const altReceivingHistory = altReceivingMap.get(product.pid) || [];
-            const noPOReceivingHistory = noPOReceivingMap.get(product.pid) || [];
+        // Insert receivings into temp table
+        if (receivings.length > 0) {
+          // Process in smaller chunks to avoid parameter limits
+          const CHUNK_SIZE = 100; // Reduce chunk size to avoid parameter limits
+          for (let i = 0; i < receivings.length; i += CHUNK_SIZE) {
+            const chunk = receivings.slice(i, Math.min(i + CHUNK_SIZE, receivings.length));
             
-            // Combine all receivings and sort by date
-            const allReceivings = [
-              ...receivingHistory.map(r => ({ ...r, type: 'original' })),
-              ...altReceivingHistory.map(r => ({ ...r, type: 'alternate' })),
-              ...noPOReceivingHistory.map(r => ({ ...r, type: 'no_po' }))
-            ].sort((a, b) => new Date(a.received_date || '9999-12-31') - new Date(b.received_date || '9999-12-31'));
-
-            // Split receivings into original PO and others
-            const originalPOReceivings = allReceivings.filter(r => r.type === 'original');
-            const otherReceivings = allReceivings.filter(r => r.type !== 'original');
-
-            // Track FIFO fulfillment
-            let remainingToFulfill = product.ordered;
-            const fulfillmentTracking = [];
-            let totalReceived = 0;
-            let actualCost = null; // Will store the cost of the first receiving that fulfills this PO
-            let firstFulfillmentReceiving = null;
-            let lastFulfillmentReceiving = null;
-
-            for (const receiving of allReceivings) {
-                // Convert quantities to base units using supplier data
-                const baseQtyReceived = receiving.qty_each * (
-                    receiving.type === 'original' ? 1 : 
-                    Math.max(1, product.supplier_qty_per_unit || 1)
-                );
-                const qtyToApply = Math.min(remainingToFulfill, baseQtyReceived);
-                
-                if (qtyToApply > 0) {
-                    // If this is the first receiving being applied, use its cost
-                    if (actualCost === null && receiving.cost_each > 0) {
-                        actualCost = receiving.cost_each;
-                        firstFulfillmentReceiving = receiving;
-                    }
-                    lastFulfillmentReceiving = receiving;
-                    fulfillmentTracking.push({
-                        receiving_id: receiving.receiving_id,
-                        qty_applied: qtyToApply,
-                        qty_total: baseQtyReceived,
-                        cost: receiving.cost_each || actualCost || product.cost_each,
-                        date: receiving.received_date,
-                        received_by: receiving.received_by,
-                        received_by_name: receiving.received_by_name || 'Unknown',
-                        type: receiving.type,
-                        remaining_qty: baseQtyReceived - qtyToApply
-                    });
-                    remainingToFulfill -= qtyToApply;
-                } else {
-                    // Track excess receivings
-                    fulfillmentTracking.push({
-                        receiving_id: receiving.receiving_id,
-                        qty_applied: 0,
-                        qty_total: baseQtyReceived,
-                        cost: receiving.cost_each || actualCost || product.cost_each,
-                        date: receiving.received_date,
-                        received_by: receiving.received_by,
-                        received_by_name: receiving.received_by_name || 'Unknown',
-                        type: receiving.type,
-                        is_excess: true
-                    });
-                }
-                totalReceived += baseQtyReceived;
-            }
-
-            const receiving_status = !totalReceived ? 1 : // created
-                                   remainingToFulfill > 0 ? 30 : // partial
-                                   40; // full
-
-            function formatDate(dateStr) {
-              if (!dateStr) return null;
-              if (dateStr === '0000-00-00' || dateStr === '0000-00-00 00:00:00') return null;
-              if (typeof dateStr === 'string' && !dateStr.match(/^\d{4}-\d{2}-\d{2}/)) return null;
-              try {
-                const date = new Date(dateStr);
-                if (isNaN(date.getTime())) return null;
-                if (date.getFullYear() < 1900 || date.getFullYear() > 2100) return null;
-                return date.toISOString().split('T')[0];
-              } catch (e) {
-                return null;
-              }
-            }
-
-            const rowValues = columnNames.map(col => {
-              switch (col) {
-                case 'po_id': return po.po_id;
-                case 'vendor': return po.vendor;
-                case 'date': return formatDate(po.date);
-                case 'expected_date': return formatDate(po.expected_date);
-                case 'pid': return product.pid;
-                case 'sku': return product.sku;
-                case 'name': return product.name;
-                case 'cost_price': return actualCost || product.cost_each;
-                case 'po_cost_price': return product.cost_each;
-                case 'status': return po.status;
-                case 'notes': return po.notes;
-                case 'long_note': return po.long_note;
-                case 'ordered': return product.ordered;
-                case 'received': return totalReceived;
-                case 'unfulfilled': return remainingToFulfill;
-                case 'excess_received': return Math.max(0, totalReceived - product.ordered);
-                case 'received_date': return formatDate(firstFulfillmentReceiving?.received_date);
-                case 'last_received_date': return formatDate(lastFulfillmentReceiving?.received_date);
-                case 'received_by': return firstFulfillmentReceiving?.received_by_name || null;
-                case 'receiving_status': return receiving_status;
-                case 'receiving_history': return JSON.stringify({
-                  fulfillment: fulfillmentTracking,
-                  ordered_qty: product.ordered,
-                  total_received: totalReceived,
-                  remaining_unfulfilled: remainingToFulfill,
-                  excess_received: Math.max(0, totalReceived - product.ordered),
-                  po_cost: product.cost_each,
-                  actual_cost: actualCost || product.cost_each
-                });
-                default: return null;
-              }
+            const values = [];
+            const placeholders = [];
+            
+            chunk.forEach((r, idx) => {
+              values.push(
+                r.po_id,
+                r.pid,
+                r.receiving_id,
+                r.qty_each,
+                r.cost_each,
+                r.received_date,
+                r.received_by,
+                r.received_by_name || null,
+                r.is_alt_po
+              );
+              
+              const offset = idx * 9;
+              placeholders.push(`($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9})`);
             });
 
-            if (existingPOMap.has(key)) {
-              const existing = existingPOMap.get(key);
-              // Check if any values are different
-              const hasChanges = columnNames.some(col => {
-                const newVal = rowValues[columnNames.indexOf(col)];
-                const oldVal = existing[col] ?? null;
-                // Special handling for numbers to avoid type coercion issues
-                if (typeof newVal === 'number' && typeof oldVal === 'number') {
-                  return Math.abs(newVal - oldVal) > 0.00001; // Allow for tiny floating point differences
-                }
-                // Special handling for receiving_history - parse and compare
-                if (col === 'receiving_history') {
-                  const newHistory = JSON.parse(newVal || '{}');
-                  const oldHistory = JSON.parse(oldVal || '{}');
-                  return JSON.stringify(newHistory) !== JSON.stringify(oldHistory);
-                }
-                return newVal !== oldVal;
-              });
-
-              if (hasChanges) {
-                insertsAndUpdates.updates.push({
-                  po_id: po.po_id,
-                  pid: product.pid,
-                  values: rowValues
-                });
-              }
-            } else {
-              insertsAndUpdates.inserts.push({
-                po_id: po.po_id,
-                pid: product.pid,
-                values: rowValues
-              });
-            }
-            batchProcessed++;
+            await localConnection.query(`
+              INSERT INTO temp_po_receivings (
+                po_id, pid, receiving_id, qty_each, cost_each, received_date,
+                received_by, received_by_name, is_alt_po
+              )
+              VALUES ${placeholders.join(',')}
+              ON CONFLICT (receiving_id, pid) DO UPDATE SET
+                po_id = EXCLUDED.po_id,
+                qty_each = EXCLUDED.qty_each,
+                cost_each = EXCLUDED.cost_each,
+                received_date = EXCLUDED.received_date,
+                received_by = EXCLUDED.received_by,
+                received_by_name = EXCLUDED.received_by_name,
+                is_alt_po = EXCLUDED.is_alt_po
+            `, values);
           }
         }
 
-        // Handle inserts
-        if (insertsAndUpdates.inserts.length > 0) {
-          const insertPlaceholders = insertsAndUpdates.inserts
-            .map(() => `(${Array(columnNames.length).fill("?").join(",")})`)
-            .join(",");
-
-          const insertResult = await localConnection.query(`
-            INSERT INTO purchase_orders (${columnNames.join(",")})
-            VALUES ${insertPlaceholders}
-          `, insertsAndUpdates.inserts.map(i => i.values).flat());
-
-          const affectedRows = insertResult[0].affectedRows;
-          // For an upsert, MySQL counts rows twice for updates
-          // So if affectedRows is odd, we have (updates * 2 + inserts)
-          const updates = Math.floor(affectedRows / 2);
-          const inserts = affectedRows - (updates * 2);
+        // Process each PO product in chunks
+        const PRODUCT_CHUNK_SIZE = 100;
+        for (let i = 0; i < productBatch.length; i += PRODUCT_CHUNK_SIZE) {
+          const chunk = productBatch.slice(i, Math.min(i + PRODUCT_CHUNK_SIZE, productBatch.length));
+          const values = [];
+          const placeholders = [];
           
-          recordsAdded += inserts;
-          recordsUpdated += Math.floor(updates); // Ensure we never have fractional updates
-          processed += batchProcessed;
-        }
-
-        // Handle updates - now we know these actually have changes
-        if (insertsAndUpdates.updates.length > 0) {
-          const updatePlaceholders = insertsAndUpdates.updates
-            .map(() => `(${Array(columnNames.length).fill("?").join(",")})`)
-            .join(",");
-
-          const updateResult = await localConnection.query(`
-            INSERT INTO purchase_orders (${columnNames.join(",")})
-            VALUES ${updatePlaceholders}
-            ON DUPLICATE KEY UPDATE ${columnNames
-              .filter((col) => col !== "po_id" && col !== "pid")
-              .map((col) => `${col} = VALUES(${col})`)
-              .join(",")};
-          `, insertsAndUpdates.updates.map(u => u.values).flat());
-
-          const affectedRows = updateResult[0].affectedRows;
-          // For an upsert, MySQL counts rows twice for updates
-          // So if affectedRows is odd, we have (updates * 2 + inserts)
-          const updates = Math.floor(affectedRows / 2);
-          const inserts = affectedRows - (updates * 2);
-          
-          recordsUpdated += Math.floor(updates); // Ensure we never have fractional updates
-          processed += batchProcessed;
-        }
-        
-        // Update progress based on time interval
-        const now = Date.now();
-        if (now - lastProgressUpdate >= PROGRESS_INTERVAL || processed === totalItems) {
-          outputProgress({
-            status: "running",
-            operation: "Purchase orders import",
-            current: processed,
-            total: totalItems,
-            elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
-            remaining: estimateRemaining(startTime, processed, totalItems),
-            rate: calculateRate(startTime, processed)
+          chunk.forEach((product, idx) => {
+            const po = batch.find(p => p.po_id === product.po_id);
+            if (!po) return;
+            
+            values.push(
+              product.po_id,
+              product.pid,
+              product.sku,
+              product.name,
+              po.vendor,
+              po.date,
+              po.expected_date,
+              po.status,
+              po.notes || po.long_note,
+              product.ordered,
+              product.cost_price
+            );
+            
+            const offset = idx * 11;  // Updated to match 11 fields
+            placeholders.push(`($${offset + 1}, $${offset + 2}, $${offset + 3}, $${offset + 4}, $${offset + 5}, $${offset + 6}, $${offset + 7}, $${offset + 8}, $${offset + 9}, $${offset + 10}, $${offset + 11})`);
           });
-          lastProgressUpdate = now;
+
+          if (placeholders.length > 0) {
+            await localConnection.query(`
+              INSERT INTO temp_purchase_orders (
+                po_id, pid, sku, name, vendor, date, expected_date, 
+                status, notes, ordered, cost_price
+              )
+              VALUES ${placeholders.join(',')}
+              ON CONFLICT (po_id, pid) DO UPDATE SET
+                sku = EXCLUDED.sku,
+                name = EXCLUDED.name,
+                vendor = EXCLUDED.vendor,
+                date = EXCLUDED.date,
+                expected_date = EXCLUDED.expected_date,
+                status = EXCLUDED.status,
+                notes = EXCLUDED.notes,
+                ordered = EXCLUDED.ordered,
+                cost_price = EXCLUDED.cost_price
+            `, values);
+          }
+
+          processed += chunk.length;
+          
+          // Update progress based on time interval
+          const now = Date.now();
+          if (now - lastProgressUpdate >= PROGRESS_INTERVAL || processed === totalItems) {
+            outputProgress({
+              status: "running",
+              operation: "Purchase orders import",
+              current: processed,
+              total: totalItems,
+              elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
+              remaining: estimateRemaining(startTime, processed, totalItems),
+              rate: calculateRate(startTime, processed)
+            });
+            lastProgressUpdate = now;
+          }
         }
       }
     }
 
-    // Only update sync status if we get here (no errors thrown)
+    // Insert final data into purchase_orders table in chunks
+    const FINAL_CHUNK_SIZE = 1000;
+    let totalProcessed = 0;
+    const totalPosResult = await localConnection.query('SELECT COUNT(*) as total_pos FROM temp_purchase_orders');
+    const total_pos = parseInt(totalPosResult.rows?.[0]?.total_pos || '0', 10);
+
+    outputProgress({
+      status: "running",
+      operation: "Purchase orders final import",
+      message: `Processing ${total_pos} purchase orders for final import`,
+      current: 0,
+      total: total_pos
+    });
+
+    // Process in chunks using cursor-based pagination
+    let lastPoId = 0;
+    let lastPid = 0;
+    let recordsAdded = 0;
+    let recordsUpdated = 0;
+
+    while (true) {
+      console.log('Fetching next chunk with lastPoId:', lastPoId, 'lastPid:', lastPid);
+      const chunkResult = await localConnection.query(`
+        SELECT po_id, pid FROM temp_purchase_orders 
+        WHERE (po_id, pid) > ($1, $2)
+        ORDER BY po_id, pid
+        LIMIT $3
+      `, [lastPoId, lastPid, FINAL_CHUNK_SIZE]);
+
+      if (!chunkResult?.rows) {
+        console.error('No rows returned from chunk query:', chunkResult);
+        break;
+      }
+
+      const chunk = chunkResult.rows;
+      console.log('Got chunk of size:', chunk.length);
+      if (chunk.length === 0) break;
+
+      const result = await localConnection.query(`
+        WITH inserted_pos AS (
+          INSERT INTO purchase_orders (
+            po_id, pid, sku, name, cost_price, po_cost_price,
+            vendor, date, expected_date, status, notes,
+            ordered, received, receiving_status,
+            received_date, last_received_date, received_by,
+            receiving_history
+          )
+          SELECT 
+            po.po_id,
+            po.pid,
+            po.sku,
+            po.name,
+            COALESCE(
+              (
+                SELECT cost_each 
+                FROM temp_po_receivings r2 
+                WHERE r2.pid = po.pid 
+                  AND r2.po_id = po.po_id
+                  AND r2.is_alt_po = 0 
+                  AND r2.cost_each > 0
+                ORDER BY r2.received_date 
+                LIMIT 1
+              ),
+              po.cost_price
+            ) as cost_price,
+            po.cost_price as po_cost_price,
+            po.vendor,
+            po.date,
+            po.expected_date,
+            po.status,
+            po.notes,
+            po.ordered,
+            COALESCE(SUM(CASE WHEN r.is_alt_po = 0 THEN r.qty_each END), 0) as received,
+            CASE 
+              WHEN COUNT(r.receiving_id) = 0 THEN 1  -- created
+              WHEN SUM(CASE WHEN r.is_alt_po = 0 THEN r.qty_each END) < po.ordered THEN 30  -- partial
+              ELSE 40  -- full
+            END as receiving_status,
+            MIN(CASE WHEN r.is_alt_po = 0 THEN r.received_date END) as received_date,
+            MAX(CASE WHEN r.is_alt_po = 0 THEN r.received_date END) as last_received_date,
+            (
+              SELECT r2.received_by_name 
+              FROM temp_po_receivings r2 
+              WHERE r2.pid = po.pid 
+                AND r2.is_alt_po = 0 
+              ORDER BY r2.received_date 
+              LIMIT 1
+            ) as received_by,
+            jsonb_build_object(
+              'ordered_qty', po.ordered,
+              'total_received', COALESCE(SUM(CASE WHEN r.is_alt_po = 0 THEN r.qty_each END), 0),
+              'remaining_unfulfilled', GREATEST(0, po.ordered - COALESCE(SUM(CASE WHEN r.is_alt_po = 0 THEN r.qty_each END), 0)),
+              'excess_received', GREATEST(0, COALESCE(SUM(CASE WHEN r.is_alt_po = 0 THEN r.qty_each END), 0) - po.ordered),
+              'po_cost', po.cost_price,
+              'actual_cost', COALESCE(
+                (
+                  SELECT cost_each 
+                  FROM temp_po_receivings r2 
+                  WHERE r2.pid = po.pid 
+                    AND r2.is_alt_po = 0 
+                    AND r2.cost_each > 0
+                  ORDER BY r2.received_date 
+                  LIMIT 1
+                ),
+                po.cost_price
+              ),
+              'fulfillment', (
+                SELECT jsonb_agg(
+                  jsonb_build_object(
+                    'receiving_id', r2.receiving_id,
+                    'qty_applied', CASE 
+                      WHEN r2.running_total <= po.ordered THEN r2.qty_each
+                      WHEN r2.running_total - r2.qty_each < po.ordered THEN po.ordered - (r2.running_total - r2.qty_each)
+                      ELSE 0
+                    END,
+                    'qty_total', r2.qty_each,
+                    'cost', r2.cost_each,
+                    'date', r2.received_date,
+                    'received_by', r2.received_by,
+                    'received_by_name', r2.received_by_name,
+                    'type', CASE r2.is_alt_po 
+                      WHEN 0 THEN 'original'
+                      WHEN 1 THEN 'alternate'
+                      ELSE 'no_po'
+                    END,
+                    'remaining_qty', CASE 
+                      WHEN r2.running_total <= po.ordered THEN 0
+                      WHEN r2.running_total - r2.qty_each < po.ordered THEN r2.running_total - po.ordered
+                      ELSE r2.qty_each
+                    END,
+                    'is_excess', r2.running_total > po.ordered
+                  )
+                  ORDER BY r2.received_date
+                ) 
+                FROM (
+                  SELECT 
+                    r2.*,
+                    SUM(r2.qty_each) OVER (
+                      PARTITION BY r2.pid 
+                      ORDER BY r2.received_date
+                      ROWS UNBOUNDED PRECEDING
+                    ) as running_total
+                  FROM temp_po_receivings r2
+                  WHERE r2.pid = po.pid
+                ) r2
+              ),
+              'alternate_po_receivings', (
+                SELECT jsonb_agg(
+                  jsonb_build_object(
+                    'receiving_id', r2.receiving_id,
+                    'qty', r2.qty_each,
+                    'cost', r2.cost_each,
+                    'date', r2.received_date,
+                    'received_by', r2.received_by,
+                    'received_by_name', r2.received_by_name
+                  )
+                  ORDER BY r2.received_date
+                )
+                FROM temp_po_receivings r2
+                WHERE r2.pid = po.pid AND r2.is_alt_po = 1
+              ),
+              'no_po_receivings', (
+                SELECT jsonb_agg(
+                  jsonb_build_object(
+                    'receiving_id', r2.receiving_id,
+                    'qty', r2.qty_each,
+                    'cost', r2.cost_each,
+                    'date', r2.received_date,
+                    'received_by', r2.received_by,
+                    'received_by_name', r2.received_by_name
+                  )
+                  ORDER BY r2.received_date
+                )
+                FROM temp_po_receivings r2
+                WHERE r2.pid = po.pid AND r2.is_alt_po = 2
+              )
+            ) as receiving_history
+          FROM temp_purchase_orders po
+          LEFT JOIN temp_po_receivings r ON po.pid = r.pid
+          WHERE (po.po_id, po.pid) IN (
+            SELECT po_id, pid FROM UNNEST($1::int[], $2::int[])
+          )
+          GROUP BY po.po_id, po.pid, po.sku, po.name, po.vendor, po.date, 
+                  po.expected_date, po.status, po.notes, po.ordered, po.cost_price
+          ON CONFLICT (po_id, pid) DO UPDATE SET
+            vendor = EXCLUDED.vendor,
+            date = EXCLUDED.date,
+            expected_date = EXCLUDED.expected_date,
+            status = EXCLUDED.status,
+            notes = EXCLUDED.notes,
+            ordered = EXCLUDED.ordered,
+            received = EXCLUDED.received,
+            receiving_status = EXCLUDED.receiving_status,
+            received_date = EXCLUDED.received_date,
+            last_received_date = EXCLUDED.last_received_date,
+            received_by = EXCLUDED.received_by,
+            receiving_history = EXCLUDED.receiving_history,
+            cost_price = EXCLUDED.cost_price,
+            po_cost_price = EXCLUDED.po_cost_price
+          RETURNING xmax
+        )
+        SELECT 
+          COUNT(*) FILTER (WHERE xmax = 0) as inserted,
+          COUNT(*) FILTER (WHERE xmax <> 0) as updated
+        FROM inserted_pos
+      `, [
+        chunk.map(r => r.po_id),
+        chunk.map(r => r.pid)
+      ]);
+
+      // Add debug logging
+      console.log('Insert result:', result?.rows?.[0]);
+
+      // Handle the result properly for PostgreSQL with more defensive coding
+      const resultRow = result?.rows?.[0] || {};
+      const insertCount = parseInt(resultRow.inserted || '0', 10);
+      const updateCount = parseInt(resultRow.updated || '0', 10);
+
+      recordsAdded += insertCount;
+      recordsUpdated += updateCount;
+      totalProcessed += chunk.length;
+
+      // Update progress
+      outputProgress({
+        status: "running",
+        operation: "Purchase orders final import",
+        message: `Processed ${totalProcessed} of ${total_pos} purchase orders`,
+        current: totalProcessed,
+        total: total_pos,
+        elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
+        remaining: estimateRemaining(startTime, totalProcessed, total_pos),
+        rate: calculateRate(startTime, totalProcessed)
+      });
+
+      // Update last processed IDs for next chunk with safety check
+      if (chunk.length > 0) {
+        const lastItem = chunk[chunk.length - 1];
+        if (lastItem) {
+          lastPoId = lastItem.po_id;
+          lastPid = lastItem.pid;
+        }
+      }
+    }
+
+    // Update sync status
     await localConnection.query(`
       INSERT INTO sync_status (table_name, last_sync_timestamp)
       VALUES ('purchase_orders', NOW())
-      ON DUPLICATE KEY UPDATE 
-        last_sync_timestamp = NOW(),
-        last_sync_id = LAST_INSERT_ID(last_sync_id)
+      ON CONFLICT (table_name) DO UPDATE SET
+        last_sync_timestamp = NOW()
+    `);
+
+    // Clean up temporary tables
+    await localConnection.query(`
+      DROP TABLE IF EXISTS temp_purchase_orders;
+      DROP TABLE IF EXISTS temp_po_receivings;
     `);
 
     return {
       status: "complete",
-      totalImported: totalItems,
-      recordsAdded: recordsAdded || 0,
-      recordsUpdated: recordsUpdated || 0,
-      incrementalUpdate,
-      lastSyncTime
+      recordsAdded,
+      recordsUpdated,
+      totalRecords: processed
     };
-
   } catch (error) {
-    outputProgress({
-      operation: `${incrementalUpdate ? 'Incremental' : 'Full'} purchase orders import failed`,
-      status: "error",
-      error: error.message,
-    });
+    console.error("Error during purchase orders import:", error);
+    // Attempt cleanup on error
+    try {
+      await localConnection.query(`
+        DROP TABLE IF EXISTS temp_purchase_orders;
+        DROP TABLE IF EXISTS temp_po_receivings;
+      `);
+    } catch (cleanupError) {
+      console.error('Error during cleanup:', cleanupError);
+    }
     throw error;
   }
 }
 
-module.exports = importPurchaseOrders; 
+module.exports = importPurchaseOrders;

inventory-server/scripts/import/utils.js

@@ -1,5 +1,6 @@
 const mysql = require("mysql2/promise");
 const { Client } = require("ssh2");
+const { Pool } = require('pg');
 const dotenv = require("dotenv");
 const path = require("path");
 
@@ -41,23 +42,90 @@ async function setupSshTunnel(sshConfig) {
 async function setupConnections(sshConfig) {
   const tunnel = await setupSshTunnel(sshConfig);
   
+  // Setup MySQL connection for production
   const prodConnection = await mysql.createConnection({
     ...sshConfig.prodDbConfig,
     stream: tunnel.stream,
   });
 
-  const localConnection = await mysql.createPool({
-    ...sshConfig.localDbConfig,
-    waitForConnections: true,
-    connectionLimit: 10,
-    queueLimit: 0
-  });
+  // Setup PostgreSQL connection pool for local
+  const localPool = new Pool(sshConfig.localDbConfig);
 
-  return {
-    ssh: tunnel.ssh,
-    prodConnection,
-    localConnection
+  // Test the PostgreSQL connection
+  try {
+    const client = await localPool.connect();
+    await client.query('SELECT NOW()');
+    client.release();
+    console.log('PostgreSQL connection successful');
+  } catch (err) {
+    console.error('PostgreSQL connection error:', err);
+    throw err;
+  }
+
+  // Create a wrapper for the PostgreSQL pool to match MySQL interface
+  const localConnection = {
+    _client: null,
+    _transactionActive: false,
+
+    query: async (text, params) => {
+      // If we're not in a transaction, use the pool directly
+      if (!localConnection._transactionActive) {
+        const client = await localPool.connect();
+        try {
+          const result = await client.query(text, params);
+          return [result];
+        } finally {
+          client.release();
+        }
+      }
+      
+      // If we're in a transaction, use the dedicated client
+      if (!localConnection._client) {
+        throw new Error('No active transaction client');
+      }
+      const result = await localConnection._client.query(text, params);
+      return [result];
+    },
+
+    beginTransaction: async () => {
+      if (localConnection._transactionActive) {
+        throw new Error('Transaction already active');
+      }
+      localConnection._client = await localPool.connect();
+      await localConnection._client.query('BEGIN');
+      localConnection._transactionActive = true;
+    },
+
+    commit: async () => {
+      if (!localConnection._transactionActive) {
+        throw new Error('No active transaction to commit');
+      }
+      await localConnection._client.query('COMMIT');
+      localConnection._client.release();
+      localConnection._client = null;
+      localConnection._transactionActive = false;
+    },
+
+    rollback: async () => {
+      if (!localConnection._transactionActive) {
+        throw new Error('No active transaction to rollback');
+      }
+      await localConnection._client.query('ROLLBACK');
+      localConnection._client.release();
+      localConnection._client = null;
+      localConnection._transactionActive = false;
+    },
+
+    end: async () => {
+      if (localConnection._client) {
+        localConnection._client.release();
+        localConnection._client = null;
+      }
+      await localPool.end();
+    }
   };
+
+  return { prodConnection, localConnection, tunnel };
 }
 
 // Helper function to close connections

inventory-server/scripts/reset-db.js

@@ -1,4 +1,4 @@
-const mysql = require('mysql2/promise');
+const { Client } = require('pg');
 const path = require('path');
 const dotenv = require('dotenv');
 const fs = require('fs');
@@ -10,7 +10,7 @@ const dbConfig = {
     user: process.env.DB_USER,
     password: process.env.DB_PASSWORD,
     database: process.env.DB_NAME,
-    multipleStatements: true
+    port: process.env.DB_PORT || 5432
 };
 
 // Helper function to output progress in JSON format
@@ -54,14 +54,44 @@ function splitSQLStatements(sql) {
     let currentStatement = '';
     let inString = false;
     let stringChar = '';
+    let inDollarQuote = false;
+    let dollarQuoteTag = '';
     
     // Process character by character
     for (let i = 0; i < sql.length; i++) {
         const char = sql[i];
         const nextChar = sql[i + 1] || '';
         
-        // Handle string literals
-        if ((char === "'" || char === '"') && sql[i - 1] !== '\\') {
+        // Handle dollar quotes
+        if (char === '$' && !inString) {
+            // Look ahead to find the dollar quote tag
+            let tag = '$';
+            let j = i + 1;
+            while (j < sql.length && sql[j] !== '$') {
+                tag += sql[j];
+                j++;
+            }
+            tag += '$';
+            
+            if (j < sql.length) { // Found closing $
+                if (!inDollarQuote) {
+                    inDollarQuote = true;
+                    dollarQuoteTag = tag;
+                    currentStatement += tag;
+                    i = j;
+                    continue;
+                } else if (sql.substring(i, j + 1) === dollarQuoteTag) {
+                    inDollarQuote = false;
+                    dollarQuoteTag = '';
+                    currentStatement += tag;
+                    i = j;
+                    continue;
+                }
+            }
+        }
+        
+        // Handle string literals (only if not in dollar quote)
+        if (!inDollarQuote && (char === "'" || char === '"') && sql[i - 1] !== '\\') {
             if (!inString) {
                 inString = true;
                 stringChar = char;
@@ -70,23 +100,25 @@ function splitSQLStatements(sql) {
             }
         }
         
-        // Handle comments
-        if (!inString && char === '-' && nextChar === '-') {
-            // Skip to end of line
-            while (i < sql.length && sql[i] !== '\n') i++;
-            continue;
+        // Handle comments (only if not in string or dollar quote)
+        if (!inString && !inDollarQuote) {
+            if (char === '-' && nextChar === '-') {
+                // Skip to end of line
+                while (i < sql.length && sql[i] !== '\n') i++;
+                continue;
+            }
+            
+            if (char === '/' && nextChar === '*') {
+                // Skip until closing */
+                i += 2;
+                while (i < sql.length && (sql[i] !== '*' || sql[i + 1] !== '/')) i++;
+                i++; // Skip the closing /
+                continue;
+            }
         }
         
-        if (!inString && char === '/' && nextChar === '*') {
-            // Skip until closing */
-            i += 2;
-            while (i < sql.length && (sql[i] !== '*' || sql[i + 1] !== '/')) i++;
-            i++; // Skip the closing /
-            continue;
-        }
-        
-        // Handle statement boundaries
-        if (!inString && char === ';') {
+        // Handle statement boundaries (only if not in string or dollar quote)
+        if (!inString && !inDollarQuote && char === ';') {
             if (currentStatement.trim()) {
                 statements.push(currentStatement.trim());
             }
@@ -120,30 +152,26 @@ async function resetDatabase() {
         }
     });
 
-    const connection = await mysql.createConnection(dbConfig);
+    const client = new Client(dbConfig);
+    await client.connect();
     
     try {
-        // Check MySQL privileges
+        // Check PostgreSQL version and user
         outputProgress({
-            operation: 'Checking privileges',
-            message: 'Verifying MySQL user privileges...'
+            operation: 'Checking database',
+            message: 'Verifying PostgreSQL version and user privileges...'
         });
 
-        const [grants] = await connection.query('SHOW GRANTS');
-        outputProgress({
-            operation: 'User privileges',
-            message: {
-                grants: grants.map(g => Object.values(g)[0])
-            }
-        });
-
-        // Enable warnings as errors
-        await connection.query('SET SESSION sql_notes = 1');
+        const versionResult = await client.query('SELECT version()');
+        const userResult = await client.query('SELECT current_user, current_database()');
         
-        // Log database config (without sensitive info)
         outputProgress({
-            operation: 'Database config',
-            message: `Using database: ${dbConfig.database} on host: ${dbConfig.host}`
+            operation: 'Database info',
+            message: {
+                version: versionResult.rows[0].version,
+                user: userResult.rows[0].current_user,
+                database: userResult.rows[0].current_database
+            }
         });
 
         // Get list of all tables in the current database
@@ -152,14 +180,14 @@ async function resetDatabase() {
             message: 'Retrieving all table names...'
         });
 
-        const [tables] = await connection.query(`
-            SELECT GROUP_CONCAT(table_name) as tables 
-            FROM information_schema.tables 
-            WHERE table_schema = DATABASE()
-            AND table_name NOT IN ('users', 'import_history', 'calculate_history')
+        const tablesResult = await client.query(`
+            SELECT string_agg(tablename, ', ') as tables
+            FROM pg_tables
+            WHERE schemaname = 'public'
+            AND tablename NOT IN ('users', 'calculate_history', 'import_history');
         `);
 
-        if (!tables[0].tables) {
+        if (!tablesResult.rows[0].tables) {
             outputProgress({
                 operation: 'No tables found',
                 message: 'Database is already empty'
@@ -170,20 +198,73 @@ async function resetDatabase() {
                 message: 'Dropping all existing tables...'
             });
 
-            await connection.query('SET FOREIGN_KEY_CHECKS = 0');
-            const dropQuery = `
-                DROP TABLE IF EXISTS 
-                ${tables[0].tables
-                    .split(',')
-                    .filter(table => !['users', 'calculate_history'].includes(table))
-                    .map(table => '`' + table + '`')
-                    .join(', ')}
-            `;
-            await connection.query(dropQuery);
-            await connection.query('SET FOREIGN_KEY_CHECKS = 1');
+            // Disable triggers/foreign key checks
+            await client.query('SET session_replication_role = \'replica\';');
+            
+            // Drop all tables except users
+            const tables = tablesResult.rows[0].tables.split(', ');
+            for (const table of tables) {
+                if (!['users'].includes(table)) {
+                    await client.query(`DROP TABLE IF EXISTS "${table}" CASCADE`);
+                }
+            }
+
+            // Only drop types if we're not preserving history tables
+            const historyTablesExist = await client.query(`
+                SELECT EXISTS (
+                    SELECT FROM pg_tables 
+                    WHERE schemaname = 'public' 
+                    AND tablename IN ('calculate_history', 'import_history')
+                );
+            `);
+
+            if (!historyTablesExist.rows[0].exists) {
+                await client.query('DROP TYPE IF EXISTS calculation_status CASCADE;');
+                await client.query('DROP TYPE IF EXISTS module_name CASCADE;');
+            }
+            
+            // Re-enable triggers/foreign key checks
+            await client.query('SET session_replication_role = \'origin\';');
         }
 
-        // Read and execute main schema (core tables)
+        // Create enum types if they don't exist
+        outputProgress({
+            operation: 'Creating enum types',
+            message: 'Setting up required enum types...'
+        });
+
+        // Check if types exist before creating
+        const typesExist = await client.query(`
+            SELECT EXISTS (
+                SELECT 1 FROM pg_type 
+                WHERE typname = 'calculation_status'
+            ) as calc_status_exists,
+            EXISTS (
+                SELECT 1 FROM pg_type 
+                WHERE typname = 'module_name'
+            ) as module_name_exists;
+        `);
+
+        if (!typesExist.rows[0].calc_status_exists) {
+            await client.query(`CREATE TYPE calculation_status AS ENUM ('running', 'completed', 'failed', 'cancelled')`);
+        }
+
+        if (!typesExist.rows[0].module_name_exists) {
+            await client.query(`
+                CREATE TYPE module_name AS ENUM (
+                    'product_metrics',
+                    'time_aggregates',
+                    'financial_metrics',
+                    'vendor_metrics',
+                    'category_metrics',
+                    'brand_metrics',
+                    'sales_forecasts',
+                    'abc_classification'
+                )
+            `);
+        }
+
+        // Read and execute main schema first (core tables)
         outputProgress({
             operation: 'Running database setup',
             message: 'Creating core tables...'
@@ -223,35 +304,24 @@ async function resetDatabase() {
         for (let i = 0; i < statements.length; i++) {
             const stmt = statements[i];
             try {
-                const [result, fields] = await connection.query(stmt);
-                
-                // Check for warnings
-                const [warnings] = await connection.query('SHOW WARNINGS');
-                if (warnings && warnings.length > 0) {
-                    outputProgress({
-                        status: 'warning',
-                        operation: 'SQL Warning',
-                        statement: i + 1,
-                        warnings: warnings
-                    });
-                }
+                const result = await client.query(stmt);
                 
                 // Verify if table was created (if this was a CREATE TABLE statement)
                 if (stmt.trim().toLowerCase().startsWith('create table')) {
-                    const tableName = stmt.match(/create\s+table\s+(?:if\s+not\s+exists\s+)?`?(\w+)`?/i)?.[1];
+                    const tableName = stmt.match(/create\s+table\s+(?:if\s+not\s+exists\s+)?["]?(\w+)["]?/i)?.[1];
                     if (tableName) {
-                        const [tableExists] = await connection.query(`
+                        const tableExists = await client.query(`
                             SELECT COUNT(*) as count 
                             FROM information_schema.tables 
-                            WHERE table_schema = DATABASE() 
-                            AND table_name = ?
+                            WHERE table_schema = 'public' 
+                            AND table_name = $1
                         `, [tableName]);
                         
                         outputProgress({
                             operation: 'Table Creation Verification',
                             message: {
                                 table: tableName,
-                                exists: tableExists[0].count > 0
+                                exists: tableExists.rows[0].count > 0
                             }
                         });
                     }
@@ -263,7 +333,7 @@ async function resetDatabase() {
                         statement: i + 1,
                         total: statements.length,
                         preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : ''),
-                        affectedRows: result.affectedRows
+                        rowCount: result.rowCount
                     }
                 });
             } catch (sqlError) {
@@ -271,8 +341,6 @@ async function resetDatabase() {
                     status: 'error',
                     operation: 'SQL Error',
                     error: sqlError.message,
-                    sqlState: sqlError.sqlState,
-                    errno: sqlError.errno,
                     statement: stmt,
                     statementNumber: i + 1
                 });
@@ -280,66 +348,12 @@ async function resetDatabase() {
             }
         }
 
-        // List all tables in the database after schema execution
-        outputProgress({
-            operation: 'Debug database',
-            message: {
-                currentDatabase: (await connection.query('SELECT DATABASE() as db'))[0][0].db
-            }
-        });
-
-        const [allTables] = await connection.query(`
-            SELECT 
-                table_schema,
-                table_name,
-                engine,
-                create_time,
-                table_rows
+        // Verify core tables were created
+        const existingTables = (await client.query(`
+            SELECT table_name
             FROM information_schema.tables 
-            WHERE table_schema = DATABASE()
-        `);
-
-        if (allTables.length === 0) {
-            outputProgress({
-                operation: 'Warning',
-                message: 'No tables found in database after schema execution'
-            });
-        } else {
-            outputProgress({
-                operation: 'Tables after schema execution',
-                message: {
-                    count: allTables.length,
-                    tables: allTables.map(t => ({
-                        schema: t.table_schema,
-                        name: t.table_name,
-                        engine: t.engine,
-                        created: t.create_time,
-                        rows: t.table_rows
-                    }))
-                }
-            });
-        }
-
-        // Also check table status
-        const [tableStatus] = await connection.query('SHOW TABLE STATUS');
-        outputProgress({
-            operation: 'Table Status',
-            message: {
-                tables: tableStatus.map(t => ({
-                    name: t.Name,
-                    engine: t.Engine,
-                    version: t.Version,
-                    rowFormat: t.Row_format,
-                    rows: t.Rows,
-                    createTime: t.Create_time,
-                    updateTime: t.Update_time
-                }))
-            }
-        });
-
-        // Verify core tables were created using SHOW TABLES
-        const [showTables] = await connection.query('SHOW TABLES');
-        const existingTables = showTables.map(t => Object.values(t)[0]);
+            WHERE table_schema = 'public'
+        `)).rows.map(t => t.table_name);
 
         outputProgress({
             operation: 'Core tables verification',
@@ -359,22 +373,12 @@ async function resetDatabase() {
             );
         }
 
-        // Verify all core tables use InnoDB
-        const [engineStatus] = await connection.query('SHOW TABLE STATUS WHERE Name IN (?)', [CORE_TABLES]);
-        const nonInnoDBTables = engineStatus.filter(t => t.Engine !== 'InnoDB');
-        
-        if (nonInnoDBTables.length > 0) {
-            throw new Error(
-                `Tables using non-InnoDB engine: ${nonInnoDBTables.map(t => t.Name).join(', ')}`
-            );
-        }
-
         outputProgress({
             operation: 'Core tables created',
             message: `Successfully created tables: ${CORE_TABLES.join(', ')}`
         });
 
-        // Read and execute config schema
+        // Now read and execute config schema (since core tables exist)
         outputProgress({
             operation: 'Running config setup',
             message: 'Creating configuration tables...'
@@ -400,18 +404,7 @@ async function resetDatabase() {
         for (let i = 0; i < configStatements.length; i++) {
             const stmt = configStatements[i];
             try {
-                const [result, fields] = await connection.query(stmt);
-                
-                // Check for warnings
-                const [warnings] = await connection.query('SHOW WARNINGS');
-                if (warnings && warnings.length > 0) {
-                    outputProgress({
-                        status: 'warning',
-                        operation: 'Config SQL Warning',
-                        statement: i + 1,
-                        warnings: warnings
-                    });
-                }
+                const result = await client.query(stmt);
                 
                 outputProgress({
                     operation: 'Config SQL Progress',
@@ -419,7 +412,7 @@ async function resetDatabase() {
                         statement: i + 1,
                         total: configStatements.length,
                         preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : ''),
-                        affectedRows: result.affectedRows
+                        rowCount: result.rowCount
                     }
                 });
             } catch (sqlError) {
@@ -427,8 +420,6 @@ async function resetDatabase() {
                     status: 'error',
                     operation: 'Config SQL Error',
                     error: sqlError.message,
-                    sqlState: sqlError.sqlState,
-                    errno: sqlError.errno,
                     statement: stmt,
                     statementNumber: i + 1
                 });
@@ -436,33 +427,6 @@ async function resetDatabase() {
             }
         }
 
-        // Verify config tables were created
-        const [showConfigTables] = await connection.query('SHOW TABLES');
-        const existingConfigTables = showConfigTables.map(t => Object.values(t)[0]);
-
-        outputProgress({
-            operation: 'Config tables verification',
-            message: {
-                found: existingConfigTables,
-                expected: CONFIG_TABLES
-            }
-        });
-
-        const missingConfigTables = CONFIG_TABLES.filter(
-            t => !existingConfigTables.includes(t)
-        );
-
-        if (missingConfigTables.length > 0) {
-            throw new Error(
-                `Failed to create config tables: ${missingConfigTables.join(', ')}`
-            );
-        }
-
-        outputProgress({
-            operation: 'Config tables created',
-            message: `Successfully created tables: ${CONFIG_TABLES.join(', ')}`
-        });
-
         // Read and execute metrics schema (metrics tables)
         outputProgress({
             operation: 'Running metrics setup',
@@ -489,18 +453,7 @@ async function resetDatabase() {
         for (let i = 0; i < metricsStatements.length; i++) {
             const stmt = metricsStatements[i];
             try {
-                const [result, fields] = await connection.query(stmt);
-                
-                // Check for warnings
-                const [warnings] = await connection.query('SHOW WARNINGS');
-                if (warnings && warnings.length > 0) {
-                    outputProgress({
-                        status: 'warning',
-                        operation: 'Metrics SQL Warning',
-                        statement: i + 1,
-                        warnings: warnings
-                    });
-                }
+                const result = await client.query(stmt);
                 
                 outputProgress({
                     operation: 'Metrics SQL Progress',
@@ -508,7 +461,7 @@ async function resetDatabase() {
                         statement: i + 1,
                         total: metricsStatements.length,
                         preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : ''),
-                        affectedRows: result.affectedRows
+                        rowCount: result.rowCount
                     }
                 });
             } catch (sqlError) {
@@ -516,8 +469,6 @@ async function resetDatabase() {
                     status: 'error',
                     operation: 'Metrics SQL Error',
                     error: sqlError.message,
-                    sqlState: sqlError.sqlState,
-                    errno: sqlError.errno,
                     statement: stmt,
                     statementNumber: i + 1
                 });
@@ -539,7 +490,7 @@ async function resetDatabase() {
         });
         process.exit(1);
     } finally {
-        await connection.end();
+        await client.end();
     }
 }
 

inventory-server/scripts/reset-metrics.js

@@ -1,4 +1,4 @@
-const mysql = require('mysql2/promise');
+const { Client } = require('pg');
 const path = require('path');
 const fs = require('fs');
 require('dotenv').config({ path: path.resolve(__dirname, '../.env') });
@@ -8,7 +8,7 @@ const dbConfig = {
     user: process.env.DB_USER,
     password: process.env.DB_PASSWORD,
     database: process.env.DB_NAME,
-    multipleStatements: true
+    port: process.env.DB_PORT || 5432
 };
 
 function outputProgress(data) {
@@ -34,8 +34,8 @@ const METRICS_TABLES = [
     'sales_forecasts',
     'temp_purchase_metrics',
     'temp_sales_metrics',
-    'vendor_metrics', //before vendor_details for foreign key
-    'vendor_time_metrics', //before vendor_details for foreign key
+    'vendor_metrics',
+    'vendor_time_metrics',
     'vendor_details'
 ];
 
@@ -90,31 +90,31 @@ function splitSQLStatements(sql) {
 }
 
 async function resetMetrics() {
-    let connection;
+    let client;
     try {
         outputProgress({
             operation: 'Starting metrics reset',
             message: 'Connecting to database...'
         });
 
-        connection = await mysql.createConnection(dbConfig);
-        await connection.beginTransaction();
+        client = new Client(dbConfig);
+        await client.connect();
 
         // First verify current state
-        const [initialTables] = await connection.query(`
-            SELECT TABLE_NAME as name
-            FROM information_schema.tables 
-            WHERE TABLE_SCHEMA = DATABASE()
-            AND TABLE_NAME IN (?)
+        const initialTables = await client.query(`
+            SELECT tablename as name
+            FROM pg_tables 
+            WHERE schemaname = 'public'
+            AND tablename = ANY($1)
         `, [METRICS_TABLES]);
 
         outputProgress({
             operation: 'Initial state',
-            message: `Found ${initialTables.length} existing metrics tables: ${initialTables.map(t => t.name).join(', ')}`
+            message: `Found ${initialTables.rows.length} existing metrics tables: ${initialTables.rows.map(t => t.name).join(', ')}`
         });
 
         // Disable foreign key checks at the start
-        await connection.query('SET FOREIGN_KEY_CHECKS = 0');
+        await client.query('SET session_replication_role = \'replica\'');
 
         // Drop all metrics tables in reverse order to handle dependencies
         outputProgress({
@@ -124,17 +124,17 @@ async function resetMetrics() {
 
         for (const table of [...METRICS_TABLES].reverse()) {
             try {
-                await connection.query(`DROP TABLE IF EXISTS ${table}`);
+                await client.query(`DROP TABLE IF EXISTS "${table}" CASCADE`);
                 
                 // Verify the table was actually dropped
-                const [checkDrop] = await connection.query(`
+                const checkDrop = await client.query(`
                     SELECT COUNT(*) as count 
-                    FROM information_schema.tables 
-                    WHERE TABLE_SCHEMA = DATABASE() 
-                    AND TABLE_NAME = ?
+                    FROM pg_tables 
+                    WHERE schemaname = 'public' 
+                    AND tablename = $1
                 `, [table]);
                 
-                if (checkDrop[0].count > 0) {
+                if (parseInt(checkDrop.rows[0].count) > 0) {
                     throw new Error(`Failed to drop table ${table} - table still exists`);
                 }
 
@@ -153,15 +153,15 @@ async function resetMetrics() {
         }
 
         // Verify all tables were dropped
-        const [afterDrop] = await connection.query(`
-            SELECT TABLE_NAME as name
-            FROM information_schema.tables 
-            WHERE TABLE_SCHEMA = DATABASE()
-            AND TABLE_NAME IN (?)
+        const afterDrop = await client.query(`
+            SELECT tablename as name
+            FROM pg_tables 
+            WHERE schemaname = 'public'
+            AND tablename = ANY($1)
         `, [METRICS_TABLES]);
 
-        if (afterDrop.length > 0) {
-            throw new Error(`Failed to drop all tables. Remaining tables: ${afterDrop.map(t => t.name).join(', ')}`);
+        if (afterDrop.rows.length > 0) {
+            throw new Error(`Failed to drop all tables. Remaining tables: ${afterDrop.rows.map(t => t.name).join(', ')}`);
         }
 
         // Read metrics schema
@@ -187,39 +187,26 @@ async function resetMetrics() {
         for (let i = 0; i < statements.length; i++) {
             const stmt = statements[i];
             try {
-                await connection.query(stmt);
-                
-                // Check for warnings
-                const [warnings] = await connection.query('SHOW WARNINGS');
-                if (warnings && warnings.length > 0) {
-                    outputProgress({
-                        status: 'warning',
-                        operation: 'SQL Warning',
-                        message: {
-                            statement: i + 1,
-                            warnings: warnings
-                        }
-                    });
-                }
+                const result = await client.query(stmt);
 
                 // If this is a CREATE TABLE statement, verify the table was created
                 if (stmt.trim().toLowerCase().startsWith('create table')) {
-                    const tableName = stmt.match(/create\s+table\s+(?:if\s+not\s+exists\s+)?`?(\w+)`?/i)?.[1];
+                    const tableName = stmt.match(/create\s+table\s+(?:if\s+not\s+exists\s+)?["]?(\w+)["]?/i)?.[1];
                     if (tableName) {
-                        const [checkCreate] = await connection.query(`
-                            SELECT TABLE_NAME as name, CREATE_TIME as created
-                            FROM information_schema.tables 
-                            WHERE TABLE_SCHEMA = DATABASE() 
-                            AND TABLE_NAME = ?
+                        const checkCreate = await client.query(`
+                            SELECT tablename as name
+                            FROM pg_tables 
+                            WHERE schemaname = 'public' 
+                            AND tablename = $1
                         `, [tableName]);
                         
-                        if (checkCreate.length === 0) {
+                        if (checkCreate.rows.length === 0) {
                             throw new Error(`Failed to create table ${tableName} - table does not exist after CREATE statement`);
                         }
 
                         outputProgress({
                             operation: 'Table created',
-                            message: `Successfully created table: ${tableName} at ${checkCreate[0].created}`
+                            message: `Successfully created table: ${tableName}`
                         });
                     }
                 }
@@ -229,7 +216,8 @@ async function resetMetrics() {
                     message: {
                         statement: i + 1,
                         total: statements.length,
-                        preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : '')
+                        preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : ''),
+                        rowCount: result.rowCount
                     }
                 });
             } catch (sqlError) {
@@ -238,8 +226,6 @@ async function resetMetrics() {
                     operation: 'SQL Error',
                     message: {
                         error: sqlError.message,
-                        sqlState: sqlError.sqlState,
-                        errno: sqlError.errno,
                         statement: stmt,
                         statementNumber: i + 1
                     }
@@ -249,7 +235,7 @@ async function resetMetrics() {
         }
 
         // Re-enable foreign key checks after all tables are created
-        await connection.query('SET FOREIGN_KEY_CHECKS = 1');
+        await client.query('SET session_replication_role = \'origin\'');
 
         // Verify metrics tables were created
         outputProgress({
@@ -257,37 +243,36 @@ async function resetMetrics() {
             message: 'Checking all metrics tables were created...'
         });
 
-        const [metricsTablesResult] = await connection.query(`
-            SELECT 
-                TABLE_NAME as name, 
-                TABLE_ROWS as \`rows\`,
-                CREATE_TIME as created
-            FROM information_schema.tables 
-            WHERE TABLE_SCHEMA = DATABASE()
-            AND TABLE_NAME IN (?)
+        const metricsTablesResult = await client.query(`
+            SELECT tablename as name
+            FROM pg_tables 
+            WHERE schemaname = 'public'
+            AND tablename = ANY($1)
         `, [METRICS_TABLES]);
 
         outputProgress({
             operation: 'Tables found',
-            message: `Found ${metricsTablesResult.length} tables: ${metricsTablesResult.map(t => 
-                `${t.name} (created: ${t.created})`
-            ).join(', ')}`
+            message: `Found ${metricsTablesResult.rows.length} tables: ${metricsTablesResult.rows.map(t => t.name).join(', ')}`
         });
 
-        const existingMetricsTables = metricsTablesResult.map(t => t.name);
+        const existingMetricsTables = metricsTablesResult.rows.map(t => t.name);
         const missingMetricsTables = METRICS_TABLES.filter(t => !existingMetricsTables.includes(t));
 
         if (missingMetricsTables.length > 0) {
             // Do one final check of the actual tables
-            const [finalCheck] = await connection.query('SHOW TABLES');
+            const finalCheck = await client.query(`
+                SELECT tablename as name
+                FROM pg_tables 
+                WHERE schemaname = 'public'
+            `);
             outputProgress({
                 operation: 'Final table check',
-                message: `All database tables: ${finalCheck.map(t => Object.values(t)[0]).join(', ')}`
+                message: `All database tables: ${finalCheck.rows.map(t => t.name).join(', ')}`
             });
             throw new Error(`Failed to create metrics tables: ${missingMetricsTables.join(', ')}`);
         }
 
-        await connection.commit();
+        await client.query('COMMIT');
         
         outputProgress({
             status: 'complete',
@@ -302,17 +287,17 @@ async function resetMetrics() {
             stack: error.stack
         });
         
-        if (connection) {
-            await connection.rollback();
+        if (client) {
+            await client.query('ROLLBACK');
             // Make sure to re-enable foreign key checks even if there's an error
-            await connection.query('SET FOREIGN_KEY_CHECKS = 1').catch(() => {});
+            await client.query('SET session_replication_role = \'origin\'').catch(() => {});
         }
         throw error;
     } finally {
-        if (connection) {
+        if (client) {
             // One final attempt to ensure foreign key checks are enabled
-            await connection.query('SET FOREIGN_KEY_CHECKS = 1').catch(() => {});
-            await connection.end();
+            await client.query('SET session_replication_role = \'origin\'').catch(() => {});
+            await client.end();
         }
     }
 }

inventory-server/src/prompts/product-validation.txt

@@ -0,0 +1,226 @@
+I will provide a JSON array with product data. Process the array by combining all products from validData and invalidData arrays into a single array, excluding any fields starting with “__”, such as “__index” or “__errors”. Process each product according to the reference guidelines below. If a field is not included in the data, do not include it in your response (e.g. do not include its key or any value) unless the specific field guidelines below say otherwise. If a product appears to be from an empty or entirely invalid line, do not include it in your response.
+
+Your response should be a JSON object with the following structure:
+{
+  "correctedData": [], // Array of corrected products
+  "changes": [], // Array of strings describing each change made
+  "warnings": [] // Array of strings with warnings or suggestions for manual review (see below for details)
+}
+
+IMPORTANT: For all fields that use IDs (categories, supplier, company, line, subline, ship_restrictions, tax_cat, artist, themes, etc.), you MUST return the ID values, not the display names. The system will handle converting IDs to display names.
+
+Using the provided guidelines, focus on:
+1. Correcting typos and any incorrect spelling or grammar
+2. Standardizing product names
+3. Correcting and enhancing descriptions by adding details, keywords, and SEO-friendly language
+4. Fixing any obvious errors or inconsistencies between similar products in measurements, prices, or quantities
+5. Adding correct categories, themes, and colors
+
+Use only the provided data and your own knowledge to make changes. Do not make assumptions or make up information that you're not sure about. If you're unable to make a change you're confident about, leave the field as is. All data passed in should be validated, corrected, and returned. All values returned should be strings, not numbers. Do not leave out any fields that were present in the original data.
+
+Possible reasons for including a warning in the warnings array:
+- If you're unable to make a change you're confident about but you believe one needs to be made
+- If there are inconsistencies in the data that could be valid but need to be reviewed
+- If not enough information is provided to make a change that you believe is needed
+- If you infer a value for a required field based on context
+
+
+----------PRODUCT FIELD GUIDELINES----------
+
+Fields: supplier, private_notes, company, line, subline, artist
+Changes: Not allowed
+Required: Return if present in the original data. Do not return if not present.
+Instructions: If present, return these fields exactly as provided with no changes
+
+Fields: upc, supplier_no, notions_no, item_number
+Changes: Formatting only
+Required: Return if present in the original data. Do not return if not present.
+Instructions: If present, trim outside white space and return these fields exactly as provided with no other changes
+
+Fields: hts_code
+Changes: Minimal, you can correct formatting, obvious errors or inconsistencies
+Required: Return if present in the original data. Do not return if not present.
+Instructions: If present, trim white space and any non-numeric characters, then return as a string. Do not validate in any other way.
+
+Fields: image_url
+Changes: Formatting only
+Required: Return if present in the original data. Do not return if not present.
+Instructions: If present, convert all comma-separated values to valid https:// URLs and return
+
+Fields: msrp, cost_each
+Changes: Minimal, you can correct formatting, obvious errors or inconsistencies
+Required: Return if present in the original data. Do not return if not present.
+Instructions: If present, strip any currency symbols and return as a string with exactly two decimal places, even if the last place is a 0.
+
+Fields: qty_per_unit, case_qty
+Changes: Minimal, you can correct formatting, obvious errors or inconsistencies
+Required: Return if present in the original data. Do not return if not present.
+Instructions: If present, strip non-numeric characters and return
+
+Fields: ship_restrictions
+Changes: Only add a value if it's not already present
+Required: You must always return a value for this field, even if it's not provided in the original data. If no value is provided, return 0.
+Instructions: Always return a value exactly as provided, or return 0 if no value is provided.
+
+Fields: eta
+Changes: Minimal, you can correct formatting, obvious errors or inconsistencies
+Required: Return if present in the original data. Do not return if not present.
+Instructions: If present, return a full month name, day is optional, no year ever (e.g. “January” or “March 3”). This value is not required if not provided.
+
+Fields: name
+Changes: Allowed to conform to guidelines, to fix typos or formatting
+Required: You must always return a value for this field, even if it's not provided in the original data. If no value is provided, return the most reasonable value possible based on the naming guidelines and the other information you have.
+Instructions: Always return a value that is corrected and enhanced per additional guidelines below
+
+Fields: description
+Changes: Full creative control allowed within guidelines
+Required: You must always return a value for this field, even if it's not provided in the original data. If no value is provided, return the most accurate description possible based on the description guidelines and the other information you have.
+Instructions: Always return a value that is corrected and enhanced per additional guidelines below
+
+Fields: weight, length, width, height
+Changes: Allowed to correct obvious errors or inconsistencies or to add missing values
+Required: You must always return a value for this field, even if it's not provided in the original data. If no value is provided, return your best guess based on the other information you have or the dimensions for similar products.
+Instructions: Always return a reasonable value (weights in ounces and dimensions in inches) that is validated against similar provided products and your knowledge of general object measurements (e.g. a sheet of paper is not going to be 3 inches thick, a pack of stickers is not going to be 250 ounces, this sheet of paper is very likely going to be the same size as that other sheet of paper from the same line). If a value is unusual or unreasonable, even wildly so, change it to match similar products or to be more reasonable. When correcting unreasonable weights or dimensions, prioritize comparisons to products from the same company and product line first, then broader category matches or common knowledge if necessary.Do not return 0 or null for any of these fields.
+
+Fields: coo
+Changes: Formatting only
+Required: Return if present in the original data. Do not return if not present.
+Instructions: If present, convert all country names and abbreviations to the official ISO 3166-1 alpha-2 two-character country code. Convert any value with more than two characters to two characters only (e.g. "United States" or "USA" should both return "US").
+
+Fields: tax_cat
+Changes: Allowed to correct obvious errors or inconsistencies or to add missing values
+Required: You must always return a value for this field, even if it's not provided in the original data. If no value is provided, return 0.
+Instructions: Always return a valid numerical tax code ID from the Available Tax Codes array below. Give preference to the value provided, but correct it if another value is more accurate. You must return a value for this field. 0 should be the default value in most cases.
+
+Fields: size_cat
+Changes: Allowed to correct obvious errors or inconsistencies or to add missing values
+Required: Return if present in the original data or if not present and applicable. Do not return if not applicable (e.g. if no size categories apply based on what you know about the product).
+Instructions: If present or if applicable, return one valid numerical size category ID from the Available Size Categories array below. Give preference to the value provided, but correct it if another value is more accurate. If the product name contains a match for one of the size categories (such as 12x12, 6x6, 2oz, etc) you MUST return that size category with the results. A value is not required if none of the size categories apply.
+
+Fields: themes
+Changes: Allowed to correct obvious errors or inconsistencies or to add missing values
+Required: Return if present in the original data or if not present and applicable. Do not return any value if not applicable (e.g. if no themes apply based on what you know about the product).
+Instructions: If present, confirm that each provided theme matches what you understand to be a theme of the product. Remove any themes that do not match and add any themes that are missing. Most products will have zero or one theme. Return a comma-separated list of numerical theme IDs from the Available Themes array below. If you choose a sub-theme, you do not need to include its parent theme in the list.
+
+Fields: colors
+Changes: Allowed to correct obvious errors or inconsistencies or to add missing values
+Required: Return if present in the original data or if not present and applicable. Do not return any value if not applicable (e.g. if no colors apply based on what you know about the product).
+Instructions: If present or if applicable, return a comma-separated list of numerical color IDs from the Available Colors array below, using the product name as the primary guide (e.g. if the name contains Blue or a blue variant, you should return the blue color ID). A value is not required if none of the colors apply. Most products will have zero colors.
+
+Fields: categories
+Changes: Allowed to correct obvious errors or inconsistencies or to add missing values
+Required: You must always return at least one value for this field, even if it's not provided in the original data. If no value is provided, return the most appropriate category or categories based on the other information you have.
+Instructions: Always return a comma-separated list of one or more valid numerical category IDs from the Available Categories array below. Give preference to the values provided, particularly if the other information isn't enough to determine a category, but correct them or add new categories if another value is more accurate. Do not return categories in the Deals or Black Friday categories, and strip these from the list if present. If you choose a subcategory at any level, you do not need to include its parent categories in the list. You must return at least one category and you can return multiple categories if applicable. All categories have equal value so their order is not important. Always try to return the most specific categories possible (e.g. one in the third level of the category hierarchy is better than one in the second level).
+
+----------PRODUCT NAMING GUIDELINES----------
+If there's only one of this type of product in a line: [Line Name] [Product Name] - [Company]
+Example: "Cosmos Infinity Chipboard - Stamperia"
+Example: "Serene Petals 6x6 Paper Pad - Prima"
+
+Multiple similar products in a line: [Differentiator] [Product Type] - [Line Name] - [Company]
+Example: "Ice & Shells Stencil - Arctic Antarctic - Stamperia"
+Example: "Astronomy Paper - Cosmos Infinity - Stamperia"
+
+Standalone products: [Product Name] - [Company]
+Example: "Hedwig Puffy Stickers - Paper House Productions"
+Example: "Heart Tree Dies - Lawn Fawn"
+
+Color-based products: [Color] [Product Name] - [Company]
+Example: "Green Valley Enamel Dots - Altenew"
+Example: "Magenta Aqua Pigment - Brutus Monroe"
+
+Complex products: [Differentiator] [Line] [Product Type] - [Company]
+Example: "Size 6 Round Black Velvet Watercolor Brush - Silver Brush Limited" (Size 6 Round is the differentiator, Black Velvet is the line, Watercolor Brush is the product type)
+
+These should not be included in the name, unless there are multiple products that are otherwise identical:
+- Product size
+- Product weight
+- Number of pages
+- How many are in the package
+
+Naming Conventions:
+- Paper sizes: Use "12x12", "8x8", "6x6" (no spaces or units of measure)
+- Company names must match backend exactly
+- Always capitalize every word in the name, including short articles like "The" and "An"
+- Use "Idea-ology" (not "idea-ology" or "Ideaology")
+- All stamps are "Stamp Set" (not "Clear Stamps" or "Rubber Stamps")
+- All dies are "Dies" or "Die" (not "Die Set")
+- Brands with their own naming conventions should be respected, such as "Doodle Cuts" for dies from Doodlebug
+
+Special Brand Rules - Ranger: 
+Format: [Product Name] - [Designer Line] - Ranger
+Possible Designers: Dylusions, Dina Wakley MEdia, Simon Hurley create., Wendy Vecchi
+Example: "Stacked Stencil - Dina Wakley MEdia - Ranger"
+
+Special Brand Rules - Tim Holtz products from Ranger:
+Format: [Color] [Product Name/Type] - Tim Holtz Distress - Ranger
+Example: "Mermaid Lagoon Tim Holtz Distress Oxide Ink Pad - Ranger"
+
+Special Brand Rules - Tim Holtz products from Sizzix or Stampers Anonymous:
+Format: [Product Name] [Product Type] by Tim Holtz - [Company]
+Example: "Leaf Fragments Thinlits Dies by Tim Holtz - Sizzix"
+
+Special Brand Rules - Tim Holtz products from Advantus/Idea-ology:
+Format: [Product Name] - Tim Holtz Idea-ology
+Example: "Tiny Vials - Tim Holtz Idea-ology"
+
+Special Brand Rules - Dies from Sizzix:
+Include die type plus "Dies" or "Die"
+Examples:
+"Art Nouveau 3-D Textured Impressions Embossing Folder - Sizzix"
+"Pocket Pals Thinlits Dies - Sizzix"
+"Butterfly Wishes Framelits Dies & Stamps - Sizzix"
+
+Important Notes
+- Ensure that product names are consistent across all products of the same type
+- Use the minimum amount of information needed to uniquely identify the product
+- Put detailed specifications in the product description, not its name
+
+Edge Cases
+- If the product is missing a company name, infer one from the other products included in the data
+- If the product is missing a clear differentiator and needs one to be unique, infer and add one from the other data provided (e.g. the description, existing size categories, etc.)
+
+Incorrect example: MVP Rugby - Collection Pack - Photoplay
+Notes: there should be no dash between the line and the product
+
+Incorrect Example: A2 Easel Cards - Black - Photoplay
+Notes: the differentiating factor should come first: “Black A2 Easel Cards - Photoplay”. Size is ok to include here because this is the name printed on the package.
+
+Incorrect Example: 6” - Scriber Needle Modeling Tool
+Notes: this product only comes in one size, so 6” isn’t needed. The company name should also be included.
+
+Incorrect Example: Slick - White - Tulip Dimensional Fabric Paint 4oz
+Notes: color should be first, then type, then product, then company, so “White Slick Dimensional Fabric Paint - Tulip”. It appears there’s only one size available so no need to differentiate in the name.
+
+Incorrect Example: Silhouette Adhesive Cork Sheets 5”X7” 8/Pkg
+Notes: should be “Adhesive Cork Sheets - Silhouette”
+
+Incorrect Example: Galaxy - Opaque - American Crafts Color Pour Resin Dyes
+Notes: “Galaxy Opaque Dye Set - Color Pour Resin - American Crafts”
+
+Incorrect Example: Slate - Lion Brand Truboo Yarn
+Notes: [Differentiator] [Line] [Product Type] - [Company] : “Slate Truboo Yarn - Lion Brand”
+
+Incorrect Example: Rose Quartz Dylusions Shimmer Paint
+Notes: “Rose Quartz Shimmer Paint - Dylusions - Ranger”
+
+
+----------PRODUCT DESCRIPTION GUIDELINES----------
+Product descriptions are an extremely important part of the listing and are the most important part of your response. Care should be taken to ensure they are correct, helpful, and SEO-friendly.
+
+If a description is provided in the data, use it as a starting point. Correct any spelling errors, typos, poor grammar, or awkward phrasing. If necessary and you have the information, add more details, describe how the customer could use it, etc. Use complete sentences and keep SEO in mind.
+
+If no description is provided, make one up using the product name, the information you have, and the other provided guidelines. At minimum, a description should be one complete sentence that starts with a capital letter and ends with a period. Unless the product is extremely complex, 2-4 sentences is usually sufficient if you have enough information.
+
+Important Notes:
+- Every description should state exactly what's included in the product (e.g. "Includes one 12x12 sheet of patterned cardstock." or "Includes one 6x12 sheet with 27 unique stickers." or "Includes 55 pieces." or "Package includes machine, power cord, 12 sheets of cardstock, 3 dies, and project instructions.")
+- Do not use the word "our" in the description (this usually shows up when we copy a description from the manufacturer). Instead use "these" or "[Company name] [product]" or similar. (e.g. don't use "Our journals are hand-made in the USA", instead use "These journals are hand made..." or "Archer & Olive journals are handmade...")
+- Don't include statements that add no value like “this is perfect for all your paper crafts”. If the product helps to solve a unique problem or has a unique feature, by all means describe it, but if it’s just a normal sheet of paper or pack of stickers, you don’t have to pretend like it’s the best thing ever. At the same time, ensure that you add enough copy to ensure good SEO.
+- State as many facts as you can about the product, considering the viewpoint of the customer and what they would want to know when looking at it. They probably want to know dimensions, what products it’s compatible with, how thick the paper is, how many sheets are included, whether the sheets are double-sided or not, which items are in the kit, etc. Say as much as you possibly can with the information that you have.
+- !!DO NOT make up information if you aren't sure about it. A minimal correct description is better than a long incorrect one!!
+
+Avoid/remove:
+- The word "Imported"
+- Any warnings about Prop 65, choking hazards, etc
+- The manufacturer's name if it's included as the very first thing in the description
+- Any statement similar to "comes in a variety of colors, each sold separately"

inventory-server/src/routes/analytics.js

@@ -6,24 +6,24 @@ router.get('/stats', async (req, res) => {
   try {
     const pool = req.app.locals.pool;
     
-    const [results] = await pool.query(`
+    const { rows: [results] } = await pool.query(`
       SELECT 
         COALESCE(
           ROUND(
             (SUM(o.price * o.quantity - p.cost_price * o.quantity) / 
-             NULLIF(SUM(o.price * o.quantity), 0)) * 100, 1
+             NULLIF(SUM(o.price * o.quantity), 0) * 100)::numeric, 1
           ),
           0
         ) as profitMargin,
         COALESCE(
           ROUND(
-            (AVG(p.price / NULLIF(p.cost_price, 0) - 1) * 100), 1
+            (AVG(p.price / NULLIF(p.cost_price, 0) - 1) * 100)::numeric, 1
           ),
           0
         ) as averageMarkup,
         COALESCE(
           ROUND(
-            SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0), 2
+            (SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0))::numeric, 2
           ),
           0
         ) as stockTurnoverRate,
@@ -31,23 +31,23 @@ router.get('/stats', async (req, res) => {
         COALESCE(COUNT(DISTINCT p.categories), 0) as categoryCount,
         COALESCE(
           ROUND(
-            AVG(o.price * o.quantity), 2
+            AVG(o.price * o.quantity)::numeric, 2
           ),
           0
         ) as averageOrderValue
       FROM products p
       LEFT JOIN orders o ON p.pid = o.pid
-      WHERE o.date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+      WHERE o.date >= CURRENT_DATE - INTERVAL '30 days'
     `);
 
     // Ensure all values are numbers
     const stats = {
-      profitMargin: Number(results[0].profitMargin) || 0,
-      averageMarkup: Number(results[0].averageMarkup) || 0,
-      stockTurnoverRate: Number(results[0].stockTurnoverRate) || 0,
-      vendorCount: Number(results[0].vendorCount) || 0,
-      categoryCount: Number(results[0].categoryCount) || 0,
-      averageOrderValue: Number(results[0].averageOrderValue) || 0
+      profitMargin: Number(results.profitmargin) || 0,
+      averageMarkup: Number(results.averagemarkup) || 0,
+      stockTurnoverRate: Number(results.stockturnoverrate) || 0,
+      vendorCount: Number(results.vendorcount) || 0,
+      categoryCount: Number(results.categorycount) || 0,
+      averageOrderValue: Number(results.averageordervalue) || 0
     };
 
     res.json(stats);
@@ -63,13 +63,13 @@ router.get('/profit', async (req, res) => {
     const pool = req.app.locals.pool;
     
     // Get profit margins by category with full path
-    const [byCategory] = await pool.query(`
+    const { rows: byCategory } = await pool.query(`
       WITH RECURSIVE category_path AS (
         SELECT 
           c.cat_id,
           c.name,
           c.parent_id,
-          CAST(c.name AS CHAR(1000)) as path
+          c.name::text as path
         FROM categories c
         WHERE c.parent_id IS NULL
         
@@ -79,7 +79,7 @@ router.get('/profit', async (req, res) => {
           c.cat_id,
           c.name,
           c.parent_id,
-          CONCAT(cp.path, ' > ', c.name)
+          cp.path || ' > ' || c.name
         FROM categories c
         JOIN category_path cp ON c.parent_id = cp.cat_id
       )
@@ -88,53 +88,46 @@ router.get('/profit', async (req, res) => {
         cp.path as categoryPath,
         ROUND(
           (SUM(o.price * o.quantity - p.cost_price * o.quantity) / 
-           NULLIF(SUM(o.price * o.quantity), 0)) * 100, 1
+           NULLIF(SUM(o.price * o.quantity), 0) * 100)::numeric, 1
         ) as profitMargin,
-        CAST(SUM(o.price * o.quantity) AS DECIMAL(15,3)) as revenue,
-        CAST(SUM(p.cost_price * o.quantity) AS DECIMAL(15,3)) as cost
+        ROUND(SUM(o.price * o.quantity)::numeric, 3) as revenue,
+        ROUND(SUM(p.cost_price * o.quantity)::numeric, 3) as cost
       FROM products p
       LEFT JOIN orders o ON p.pid = o.pid
       JOIN product_categories pc ON p.pid = pc.pid
       JOIN categories c ON pc.cat_id = c.cat_id
       JOIN category_path cp ON c.cat_id = cp.cat_id
-      WHERE o.date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+      WHERE o.date >= CURRENT_DATE - INTERVAL '30 days'
       GROUP BY c.name, cp.path
       ORDER BY profitMargin DESC
       LIMIT 10
     `);
 
     // Get profit margin trend over time
-    const [overTime] = await pool.query(`
+    const { rows: overTime } = await pool.query(`
       SELECT 
-        formatted_date as date,
+        to_char(o.date, 'YYYY-MM-DD') as date,
         ROUND(
           (SUM(o.price * o.quantity - p.cost_price * o.quantity) / 
-           NULLIF(SUM(o.price * o.quantity), 0)) * 100, 1
+           NULLIF(SUM(o.price * o.quantity), 0) * 100)::numeric, 1
         ) as profitMargin,
-        CAST(SUM(o.price * o.quantity) AS DECIMAL(15,3)) as revenue,
-        CAST(SUM(p.cost_price * o.quantity) AS DECIMAL(15,3)) as cost
+        ROUND(SUM(o.price * o.quantity)::numeric, 3) as revenue,
+        ROUND(SUM(p.cost_price * o.quantity)::numeric, 3) as cost
       FROM products p
       LEFT JOIN orders o ON p.pid = o.pid
-      CROSS JOIN (
-        SELECT DATE_FORMAT(o.date, '%Y-%m-%d') as formatted_date
-        FROM orders o
-        WHERE o.date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
-        GROUP BY DATE_FORMAT(o.date, '%Y-%m-%d')
-      ) dates
-      WHERE o.date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
-        AND DATE_FORMAT(o.date, '%Y-%m-%d') = dates.formatted_date
-      GROUP BY formatted_date
-      ORDER BY formatted_date
+      WHERE o.date >= CURRENT_DATE - INTERVAL '30 days'
+      GROUP BY to_char(o.date, 'YYYY-MM-DD')
+      ORDER BY date
     `);
 
     // Get top performing products with category paths
-    const [topProducts] = await pool.query(`
+    const { rows: topProducts } = await pool.query(`
       WITH RECURSIVE category_path AS (
         SELECT 
           c.cat_id,
           c.name,
           c.parent_id,
-          CAST(c.name AS CHAR(1000)) as path
+          c.name::text as path
         FROM categories c
         WHERE c.parent_id IS NULL
         
@@ -144,7 +137,7 @@ router.get('/profit', async (req, res) => {
           c.cat_id,
           c.name,
           c.parent_id,
-          CONCAT(cp.path, ' > ', c.name)
+          cp.path || ' > ' || c.name
         FROM categories c
         JOIN category_path cp ON c.parent_id = cp.cat_id
       )
@@ -154,18 +147,18 @@ router.get('/profit', async (req, res) => {
         cp.path as categoryPath,
         ROUND(
           (SUM(o.price * o.quantity - p.cost_price * o.quantity) / 
-           NULLIF(SUM(o.price * o.quantity), 0)) * 100, 1
+           NULLIF(SUM(o.price * o.quantity), 0) * 100)::numeric, 1
         ) as profitMargin,
-        CAST(SUM(o.price * o.quantity) AS DECIMAL(15,3)) as revenue,
-        CAST(SUM(p.cost_price * o.quantity) AS DECIMAL(15,3)) as cost
+        ROUND(SUM(o.price * o.quantity)::numeric, 3) as revenue,
+        ROUND(SUM(p.cost_price * o.quantity)::numeric, 3) as cost
       FROM products p
       LEFT JOIN orders o ON p.pid = o.pid
       JOIN product_categories pc ON p.pid = pc.pid
       JOIN categories c ON pc.cat_id = c.cat_id
       JOIN category_path cp ON c.cat_id = cp.cat_id
-      WHERE o.date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+      WHERE o.date >= CURRENT_DATE - INTERVAL '30 days'
       GROUP BY p.pid, p.title, c.name, cp.path
-      HAVING revenue > 0
+      HAVING SUM(o.price * o.quantity) > 0
       ORDER BY profitMargin DESC
       LIMIT 10
     `);
@@ -185,7 +178,7 @@ router.get('/vendors', async (req, res) => {
     console.log('Fetching vendor performance data...');
 
     // First check if we have any vendors with sales
-    const [checkData] = await pool.query(`
+    const { rows: [checkData] } = await pool.query(`
       SELECT COUNT(DISTINCT p.vendor) as vendor_count,
              COUNT(DISTINCT o.order_number) as order_count
       FROM products p
@@ -193,39 +186,39 @@ router.get('/vendors', async (req, res) => {
       WHERE p.vendor IS NOT NULL
     `);
     
-    console.log('Vendor data check:', checkData[0]);
+    console.log('Vendor data check:', checkData);
     
     // Get vendor performance metrics
-    const [performance] = await pool.query(`
+    const { rows: performance } = await pool.query(`
       WITH monthly_sales AS (
         SELECT 
           p.vendor,
-          CAST(SUM(CASE 
-            WHEN o.date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY) 
+          ROUND(SUM(CASE 
+            WHEN o.date >= CURRENT_DATE - INTERVAL '30 days'
             THEN o.price * o.quantity 
             ELSE 0 
-          END) AS DECIMAL(15,3)) as current_month,
-          CAST(SUM(CASE 
-            WHEN o.date >= DATE_SUB(CURDATE(), INTERVAL 60 DAY) 
-            AND o.date < DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+          END)::numeric, 3) as current_month,
+          ROUND(SUM(CASE 
+            WHEN o.date >= CURRENT_DATE - INTERVAL '60 days'
+            AND o.date < CURRENT_DATE - INTERVAL '30 days'
             THEN o.price * o.quantity 
             ELSE 0 
-          END) AS DECIMAL(15,3)) as previous_month
+          END)::numeric, 3) as previous_month
         FROM products p
         LEFT JOIN orders o ON p.pid = o.pid
         WHERE p.vendor IS NOT NULL
-          AND o.date >= DATE_SUB(CURDATE(), INTERVAL 60 DAY)
+          AND o.date >= CURRENT_DATE - INTERVAL '60 days'
         GROUP BY p.vendor
       )
       SELECT 
         p.vendor,
-        CAST(SUM(o.price * o.quantity) AS DECIMAL(15,3)) as salesVolume,
+        ROUND(SUM(o.price * o.quantity)::numeric, 3) as salesVolume,
         COALESCE(ROUND(
           (SUM(o.price * o.quantity - p.cost_price * o.quantity) / 
-           NULLIF(SUM(o.price * o.quantity), 0)) * 100, 1
+           NULLIF(SUM(o.price * o.quantity), 0) * 100)::numeric, 1
         ), 0) as profitMargin,
         COALESCE(ROUND(
-          SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0), 1
+          (SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0))::numeric, 1
         ), 0) as stockTurnover,
         COUNT(DISTINCT p.pid) as productCount,
         ROUND(
@@ -236,7 +229,7 @@ router.get('/vendors', async (req, res) => {
       LEFT JOIN orders o ON p.pid = o.pid
       LEFT JOIN monthly_sales ms ON p.vendor = ms.vendor
       WHERE p.vendor IS NOT NULL
-        AND o.date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+        AND o.date >= CURRENT_DATE - INTERVAL '30 days'
       GROUP BY p.vendor, ms.current_month, ms.previous_month
       ORDER BY salesVolume DESC
       LIMIT 10
@@ -244,45 +237,7 @@ router.get('/vendors', async (req, res) => {
 
     console.log('Performance data:', performance);
 
-    // Get vendor comparison data
-    const [comparison] = await pool.query(`
-      SELECT 
-        p.vendor,
-        CAST(COALESCE(ROUND(SUM(o.price * o.quantity) / NULLIF(COUNT(DISTINCT p.pid), 0), 2), 0) AS DECIMAL(15,3)) as salesPerProduct,
-        COALESCE(ROUND(AVG((o.price - p.cost_price) / NULLIF(o.price, 0) * 100), 1), 0) as averageMargin,
-        COUNT(DISTINCT p.pid) as size
-      FROM products p
-      LEFT JOIN orders o ON p.pid = o.pid AND o.date >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
-      WHERE p.vendor IS NOT NULL
-      GROUP BY p.vendor
-      ORDER BY salesPerProduct DESC
-      LIMIT 20
-    `);
-
-    console.log('Comparison data:', comparison);
-
-    // Get vendor sales trends
-    const [trends] = await pool.query(`
-      SELECT 
-        p.vendor,
-        DATE_FORMAT(o.date, '%b %Y') as month,
-        CAST(COALESCE(SUM(o.price * o.quantity), 0) AS DECIMAL(15,3)) as sales
-      FROM products p
-      LEFT JOIN orders o ON p.pid = o.pid
-      WHERE p.vendor IS NOT NULL
-        AND o.date >= DATE_SUB(CURDATE(), INTERVAL 6 MONTH)
-      GROUP BY 
-        p.vendor,
-        DATE_FORMAT(o.date, '%b %Y'),
-        DATE_FORMAT(o.date, '%Y-%m')
-      ORDER BY 
-        p.vendor,
-        DATE_FORMAT(o.date, '%Y-%m')
-    `);
-
-    console.log('Trends data:', trends);
-
-    res.json({ performance, comparison, trends });
+    res.json({ performance });
   } catch (error) {
     console.error('Error fetching vendor performance:', error);
     res.status(500).json({ error: 'Failed to fetch vendor performance' });

inventory-server/src/routes/categories.js

@@ -6,7 +6,7 @@ router.get('/', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     // Get all categories with metrics and hierarchy info
-    const [categories] = await pool.query(`
+    const { rows: categories } = await pool.query(`
       SELECT 
         c.cat_id,
         c.name,
@@ -18,7 +18,7 @@ router.get('/', async (req, res) => {
         p.type as parent_type,
         COALESCE(cm.product_count, 0) as product_count,
         COALESCE(cm.active_products, 0) as active_products,
-        CAST(COALESCE(cm.total_value, 0) AS DECIMAL(15,3)) as total_value,
+        ROUND(COALESCE(cm.total_value, 0)::numeric, 3) as total_value,
         COALESCE(cm.avg_margin, 0) as avg_margin,
         COALESCE(cm.turnover_rate, 0) as turnover_rate,
         COALESCE(cm.growth_rate, 0) as growth_rate
@@ -39,22 +39,22 @@ router.get('/', async (req, res) => {
     `);
 
     // Get overall stats
-    const [stats] = await pool.query(`
+    const { rows: [stats] } = await pool.query(`
       SELECT 
         COUNT(DISTINCT c.cat_id) as totalCategories,
         COUNT(DISTINCT CASE WHEN c.status = 'active' THEN c.cat_id END) as activeCategories,
-        CAST(COALESCE(SUM(cm.total_value), 0) AS DECIMAL(15,3)) as totalValue,
-        COALESCE(ROUND(AVG(NULLIF(cm.avg_margin, 0)), 1), 0) as avgMargin,
-        COALESCE(ROUND(AVG(NULLIF(cm.growth_rate, 0)), 1), 0) as avgGrowth
+        ROUND(COALESCE(SUM(cm.total_value), 0)::numeric, 3) as totalValue,
+        COALESCE(ROUND(AVG(NULLIF(cm.avg_margin, 0))::numeric, 1), 0) as avgMargin,
+        COALESCE(ROUND(AVG(NULLIF(cm.growth_rate, 0))::numeric, 1), 0) as avgGrowth
       FROM categories c
       LEFT JOIN category_metrics cm ON c.cat_id = cm.category_id
     `);
 
     // Get type counts for filtering
-    const [typeCounts] = await pool.query(`
+    const { rows: typeCounts } = await pool.query(`
       SELECT 
         type,
-        COUNT(*) as count
+        COUNT(*)::integer as count
       FROM categories
       GROUP BY type
       ORDER BY type
@@ -81,14 +81,14 @@ router.get('/', async (req, res) => {
       })),
       typeCounts: typeCounts.map(tc => ({
         type: tc.type,
-        count: parseInt(tc.count)
+        count: tc.count // Already cast to integer in the query
       })),
       stats: {
-        totalCategories: parseInt(stats[0].totalCategories),
-        activeCategories: parseInt(stats[0].activeCategories),
-        totalValue: parseFloat(stats[0].totalValue),
-        avgMargin: parseFloat(stats[0].avgMargin),
-        avgGrowth: parseFloat(stats[0].avgGrowth)
+        totalCategories: parseInt(stats.totalcategories),
+        activeCategories: parseInt(stats.activecategories),
+        totalValue: parseFloat(stats.totalvalue),
+        avgMargin: parseFloat(stats.avgmargin),
+        avgGrowth: parseFloat(stats.avggrowth)
       }
     });
   } catch (error) {

inventory-server/src/routes/config.js

@@ -13,22 +13,22 @@ router.get('/', async (req, res) => {
   try {
     console.log('[Config Route] Fetching configuration values...');
     
-    const [stockThresholds] = await pool.query('SELECT * FROM stock_thresholds WHERE id = 1');
+    const { rows: stockThresholds } = await pool.query('SELECT * FROM stock_thresholds WHERE id = 1');
     console.log('[Config Route] Stock thresholds:', stockThresholds);
     
-    const [leadTimeThresholds] = await pool.query('SELECT * FROM lead_time_thresholds WHERE id = 1');
+    const { rows: leadTimeThresholds } = await pool.query('SELECT * FROM lead_time_thresholds WHERE id = 1');
     console.log('[Config Route] Lead time thresholds:', leadTimeThresholds);
     
-    const [salesVelocityConfig] = await pool.query('SELECT * FROM sales_velocity_config WHERE id = 1');
+    const { rows: salesVelocityConfig } = await pool.query('SELECT * FROM sales_velocity_config WHERE id = 1');
     console.log('[Config Route] Sales velocity config:', salesVelocityConfig);
     
-    const [abcConfig] = await pool.query('SELECT * FROM abc_classification_config WHERE id = 1');
+    const { rows: abcConfig } = await pool.query('SELECT * FROM abc_classification_config WHERE id = 1');
     console.log('[Config Route] ABC config:', abcConfig);
     
-    const [safetyStockConfig] = await pool.query('SELECT * FROM safety_stock_config WHERE id = 1');
+    const { rows: safetyStockConfig } = await pool.query('SELECT * FROM safety_stock_config WHERE id = 1');
     console.log('[Config Route] Safety stock config:', safetyStockConfig);
     
-    const [turnoverConfig] = await pool.query('SELECT * FROM turnover_config WHERE id = 1');
+    const { rows: turnoverConfig } = await pool.query('SELECT * FROM turnover_config WHERE id = 1');
     console.log('[Config Route] Turnover config:', turnoverConfig);
 
     const response = {
@@ -53,14 +53,14 @@ router.put('/stock-thresholds/:id', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     const { critical_days, reorder_days, overstock_days, low_stock_threshold, min_reorder_quantity } = req.body;
-    const [result] = await pool.query(
+    const { rows } = await pool.query(
       `UPDATE stock_thresholds 
-       SET critical_days = ?,
-           reorder_days = ?,
-           overstock_days = ?,
-           low_stock_threshold = ?,
-           min_reorder_quantity = ?
-       WHERE id = ?`,
+       SET critical_days = $1,
+           reorder_days = $2,
+           overstock_days = $3,
+           low_stock_threshold = $4,
+           min_reorder_quantity = $5
+       WHERE id = $6`,
       [critical_days, reorder_days, overstock_days, low_stock_threshold, min_reorder_quantity, req.params.id]
     );
     res.json({ success: true });
@@ -75,12 +75,12 @@ router.put('/lead-time-thresholds/:id', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     const { target_days, warning_days, critical_days } = req.body;
-    const [result] = await pool.query(
+    const { rows } = await pool.query(
       `UPDATE lead_time_thresholds 
-       SET target_days = ?,
-           warning_days = ?,
-           critical_days = ?
-       WHERE id = ?`,
+       SET target_days = $1,
+           warning_days = $2,
+           critical_days = $3
+       WHERE id = $4`,
       [target_days, warning_days, critical_days, req.params.id]
     );
     res.json({ success: true });
@@ -95,12 +95,12 @@ router.put('/sales-velocity/:id', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     const { daily_window_days, weekly_window_days, monthly_window_days } = req.body;
-    const [result] = await pool.query(
+    const { rows } = await pool.query(
       `UPDATE sales_velocity_config 
-       SET daily_window_days = ?,
-           weekly_window_days = ?,
-           monthly_window_days = ?
-       WHERE id = ?`,
+       SET daily_window_days = $1,
+           weekly_window_days = $2,
+           monthly_window_days = $3
+       WHERE id = $4`,
       [daily_window_days, weekly_window_days, monthly_window_days, req.params.id]
     );
     res.json({ success: true });
@@ -115,12 +115,12 @@ router.put('/abc-classification/:id', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     const { a_threshold, b_threshold, classification_period_days } = req.body;
-    const [result] = await pool.query(
+    const { rows } = await pool.query(
       `UPDATE abc_classification_config 
-       SET a_threshold = ?,
-           b_threshold = ?,
-           classification_period_days = ?
-       WHERE id = ?`,
+       SET a_threshold = $1,
+           b_threshold = $2,
+           classification_period_days = $3
+       WHERE id = $4`,
       [a_threshold, b_threshold, classification_period_days, req.params.id]
     );
     res.json({ success: true });
@@ -135,11 +135,11 @@ router.put('/safety-stock/:id', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     const { coverage_days, service_level } = req.body;
-    const [result] = await pool.query(
+    const { rows } = await pool.query(
       `UPDATE safety_stock_config 
-       SET coverage_days = ?,
-           service_level = ?
-       WHERE id = ?`,
+       SET coverage_days = $1,
+           service_level = $2
+       WHERE id = $3`,
       [coverage_days, service_level, req.params.id]
     );
     res.json({ success: true });
@@ -154,11 +154,11 @@ router.put('/turnover/:id', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     const { calculation_period_days, target_rate } = req.body;
-    const [result] = await pool.query(
+    const { rows } = await pool.query(
       `UPDATE turnover_config 
-       SET calculation_period_days = ?,
-           target_rate = ?
-       WHERE id = ?`,
+       SET calculation_period_days = $1,
+           target_rate = $2
+       WHERE id = $3`,
       [calculation_period_days, target_rate, req.params.id]
     );
     res.json({ success: true });

inventory-server/src/routes/csv.js

@@ -750,8 +750,16 @@ router.post('/full-reset', async (req, res) => {
 router.get('/history/import', async (req, res) => {
     try {
         const pool = req.app.locals.pool;
-        const [rows] = await pool.query(`
-            SELECT * FROM import_history 
+        const { rows } = await pool.query(`
+            SELECT 
+                id,
+                start_time,
+                end_time,
+                status,
+                error_message,
+                rows_processed::integer,
+                files_processed::integer
+            FROM import_history 
             ORDER BY start_time DESC 
             LIMIT 20
         `);
@@ -766,8 +774,16 @@ router.get('/history/import', async (req, res) => {
 router.get('/history/calculate', async (req, res) => {
     try {
         const pool = req.app.locals.pool;
-        const [rows] = await pool.query(`
-            SELECT * FROM calculate_history 
+        const { rows } = await pool.query(`
+            SELECT 
+                id,
+                start_time,
+                end_time,
+                status,
+                error_message,
+                modules_processed::integer,
+                total_modules::integer
+            FROM calculate_history 
             ORDER BY start_time DESC 
             LIMIT 20
         `);
@@ -782,8 +798,10 @@ router.get('/history/calculate', async (req, res) => {
 router.get('/status/modules', async (req, res) => {
     try {
         const pool = req.app.locals.pool;
-        const [rows] = await pool.query(`
-            SELECT module_name, last_calculation_timestamp 
+        const { rows } = await pool.query(`
+            SELECT 
+                module_name, 
+                last_calculation_timestamp::timestamp 
             FROM calculate_status 
             ORDER BY module_name
         `);
@@ -798,8 +816,10 @@ router.get('/status/modules', async (req, res) => {
 router.get('/status/tables', async (req, res) => {
     try {
         const pool = req.app.locals.pool;
-        const [rows] = await pool.query(`
-            SELECT table_name, last_sync_timestamp 
+        const { rows } = await pool.query(`
+            SELECT 
+                table_name, 
+                last_sync_timestamp::timestamp 
             FROM sync_status 
             ORDER BY table_name
         `);

inventory-server/src/routes/dashboard.js

@@ -19,16 +19,15 @@ async function executeQuery(sql, params = []) {
 router.get('/stock/metrics', async (req, res) => {
     try {
         // Get stock metrics
-        const [rows] = await executeQuery(`
+        const { rows: [stockMetrics] } = await executeQuery(`
             SELECT 
-                COALESCE(COUNT(*), 0) as total_products,
-                COALESCE(COUNT(CASE WHEN stock_quantity > 0 THEN 1 END), 0) as products_in_stock,
-                COALESCE(SUM(CASE WHEN stock_quantity > 0 THEN stock_quantity END), 0) as total_units,
-                COALESCE(SUM(CASE WHEN stock_quantity > 0 THEN stock_quantity * cost_price END), 0) as total_cost,
-                COALESCE(SUM(CASE WHEN stock_quantity > 0 THEN stock_quantity * price END), 0) as total_retail
+                COALESCE(COUNT(*), 0)::integer as total_products,
+                COALESCE(COUNT(CASE WHEN stock_quantity > 0 THEN 1 END), 0)::integer as products_in_stock,
+                COALESCE(SUM(CASE WHEN stock_quantity > 0 THEN stock_quantity END), 0)::integer as total_units,
+                ROUND(COALESCE(SUM(CASE WHEN stock_quantity > 0 THEN stock_quantity * cost_price END), 0)::numeric, 3) as total_cost,
+                ROUND(COALESCE(SUM(CASE WHEN stock_quantity > 0 THEN stock_quantity * price END), 0)::numeric, 3) as total_retail
             FROM products
         `);
-        const stockMetrics = rows[0];
 
         console.log('Raw stockMetrics from database:', stockMetrics);
         console.log('stockMetrics.total_products:', stockMetrics.total_products);
@@ -38,26 +37,26 @@ router.get('/stock/metrics', async (req, res) => {
         console.log('stockMetrics.total_retail:', stockMetrics.total_retail);
 
         // Get brand stock values with Other category
-        const [brandValues] = await executeQuery(`
+        const { rows: brandValues } = await executeQuery(`
             WITH brand_totals AS (
                 SELECT 
                     COALESCE(brand, 'Unbranded') as brand,
-                    COUNT(DISTINCT pid) as variant_count,
-                    COALESCE(SUM(stock_quantity), 0) as stock_units,
-                    CAST(COALESCE(SUM(stock_quantity * cost_price), 0) AS DECIMAL(15,3)) as stock_cost,
-                    CAST(COALESCE(SUM(stock_quantity * price), 0) AS DECIMAL(15,3)) as stock_retail
+                    COUNT(DISTINCT pid)::integer as variant_count,
+                    COALESCE(SUM(stock_quantity), 0)::integer as stock_units,
+                    ROUND(COALESCE(SUM(stock_quantity * cost_price), 0)::numeric, 3) as stock_cost,
+                    ROUND(COALESCE(SUM(stock_quantity * price), 0)::numeric, 3) as stock_retail
                 FROM products
                 WHERE stock_quantity > 0
                 GROUP BY COALESCE(brand, 'Unbranded')
-                HAVING stock_cost > 0
+                HAVING ROUND(COALESCE(SUM(stock_quantity * cost_price), 0)::numeric, 3) > 0
             ),
             other_brands AS (
                 SELECT 
                     'Other' as brand,
-                    SUM(variant_count) as variant_count,
-                    SUM(stock_units) as stock_units,
-                    CAST(SUM(stock_cost) AS DECIMAL(15,3)) as stock_cost,
-                    CAST(SUM(stock_retail) AS DECIMAL(15,3)) as stock_retail
+                    SUM(variant_count)::integer as variant_count,
+                    SUM(stock_units)::integer as stock_units,
+                    ROUND(SUM(stock_cost)::numeric, 3) as stock_cost,
+                    ROUND(SUM(stock_retail)::numeric, 3) as stock_retail
                 FROM brand_totals
                 WHERE stock_cost <= 5000
             ),
@@ -101,51 +100,50 @@ router.get('/stock/metrics', async (req, res) => {
 // Returns purchase order metrics by vendor
 router.get('/purchase/metrics', async (req, res) => {
     try {
-        const [rows] = await executeQuery(`
+        const { rows: [poMetrics] } = await executeQuery(`
             SELECT 
                 COALESCE(COUNT(DISTINCT CASE 
-                    WHEN po.receiving_status < ${ReceivingStatus.PartialReceived} 
+                    WHEN po.receiving_status < $1 
                     THEN po.po_id 
-                END), 0) as active_pos,
+                END), 0)::integer as active_pos,
                 COALESCE(COUNT(DISTINCT CASE 
-                    WHEN po.receiving_status < ${ReceivingStatus.PartialReceived} 
-                    AND po.expected_date < CURDATE() 
+                    WHEN po.receiving_status < $1 
+                    AND po.expected_date < CURRENT_DATE 
                     THEN po.po_id 
-                END), 0) as overdue_pos,
+                END), 0)::integer as overdue_pos,
                 COALESCE(SUM(CASE 
-                    WHEN po.receiving_status < ${ReceivingStatus.PartialReceived} 
+                    WHEN po.receiving_status < $1 
                     THEN po.ordered 
                     ELSE 0 
-                END), 0) as total_units,
-                CAST(COALESCE(SUM(CASE 
-                    WHEN po.receiving_status < ${ReceivingStatus.PartialReceived} 
+                END), 0)::integer as total_units,
+                ROUND(COALESCE(SUM(CASE 
+                    WHEN po.receiving_status < $1 
                     THEN po.ordered * po.cost_price 
                     ELSE 0 
-                END), 0) AS DECIMAL(15,3)) as total_cost,
-                CAST(COALESCE(SUM(CASE 
-                    WHEN po.receiving_status < ${ReceivingStatus.PartialReceived} 
+                END), 0)::numeric, 3) as total_cost,
+                ROUND(COALESCE(SUM(CASE 
+                    WHEN po.receiving_status < $1 
                     THEN po.ordered * p.price 
                     ELSE 0 
-                END), 0) AS DECIMAL(15,3)) as total_retail
+                END), 0)::numeric, 3) as total_retail
             FROM purchase_orders po
             JOIN products p ON po.pid = p.pid
-        `);
-        const poMetrics = rows[0];
+        `, [ReceivingStatus.PartialReceived]);
 
-        const [vendorOrders] = await executeQuery(`
+        const { rows: vendorOrders } = await executeQuery(`
             SELECT 
                 po.vendor,
-                COUNT(DISTINCT po.po_id) as orders,
-                COALESCE(SUM(po.ordered), 0) as units,
-                CAST(COALESCE(SUM(po.ordered * po.cost_price), 0) AS DECIMAL(15,3)) as cost,
-                CAST(COALESCE(SUM(po.ordered * p.price), 0) AS DECIMAL(15,3)) as retail
+                COUNT(DISTINCT po.po_id)::integer as orders,
+                COALESCE(SUM(po.ordered), 0)::integer as units,
+                ROUND(COALESCE(SUM(po.ordered * po.cost_price), 0)::numeric, 3) as cost,
+                ROUND(COALESCE(SUM(po.ordered * p.price), 0)::numeric, 3) as retail
             FROM purchase_orders po
             JOIN products p ON po.pid = p.pid
-            WHERE po.receiving_status < ${ReceivingStatus.PartialReceived}
+            WHERE po.receiving_status < $1
             GROUP BY po.vendor
-            HAVING cost > 0
+            HAVING ROUND(COALESCE(SUM(po.ordered * po.cost_price), 0)::numeric, 3) > 0
             ORDER BY cost DESC
-        `);
+        `, [ReceivingStatus.PartialReceived]);
 
         // Format response to match PurchaseMetricsData interface
         const response = {
@@ -175,21 +173,21 @@ router.get('/purchase/metrics', async (req, res) => {
 router.get('/replenishment/metrics', async (req, res) => {
     try {
         // Get summary metrics
-        const [metrics] = await executeQuery(`
+        const { rows: [metrics] } = await executeQuery(`
             SELECT 
-                COUNT(DISTINCT p.pid) as products_to_replenish,
+                COUNT(DISTINCT p.pid)::integer as products_to_replenish,
                 COALESCE(SUM(CASE 
                     WHEN p.stock_quantity < 0 THEN ABS(p.stock_quantity) + pm.reorder_qty
                     ELSE pm.reorder_qty 
-                END), 0) as total_units_needed,
-                CAST(COALESCE(SUM(CASE 
+                END), 0)::integer as total_units_needed,
+                ROUND(COALESCE(SUM(CASE 
                     WHEN p.stock_quantity < 0 THEN (ABS(p.stock_quantity) + pm.reorder_qty) * p.cost_price
                     ELSE pm.reorder_qty * p.cost_price 
-                END), 0) AS DECIMAL(15,3)) as total_cost,
-                CAST(COALESCE(SUM(CASE 
+                END), 0)::numeric, 3) as total_cost,
+                ROUND(COALESCE(SUM(CASE 
                     WHEN p.stock_quantity < 0 THEN (ABS(p.stock_quantity) + pm.reorder_qty) * p.price
                     ELSE pm.reorder_qty * p.price 
-                END), 0) AS DECIMAL(15,3)) as total_retail
+                END), 0)::numeric, 3) as total_retail
             FROM products p
             JOIN product_metrics pm ON p.pid = pm.pid
             WHERE p.replenishable = true
@@ -199,23 +197,23 @@ router.get('/replenishment/metrics', async (req, res) => {
         `);
 
         // Get top variants to replenish
-        const [variants] = await executeQuery(`
+        const { rows: variants } = await executeQuery(`
             SELECT 
                 p.pid,
                 p.title,
-                p.stock_quantity as current_stock,
+                p.stock_quantity::integer as current_stock,
                 CASE 
                     WHEN p.stock_quantity < 0 THEN ABS(p.stock_quantity) + pm.reorder_qty
                     ELSE pm.reorder_qty 
-                END as replenish_qty,
-                CAST(CASE 
+                END::integer as replenish_qty,
+                ROUND(CASE 
                     WHEN p.stock_quantity < 0 THEN (ABS(p.stock_quantity) + pm.reorder_qty) * p.cost_price
                     ELSE pm.reorder_qty * p.cost_price 
-                END AS DECIMAL(15,3)) as replenish_cost,
-                CAST(CASE 
+                END::numeric, 3) as replenish_cost,
+                ROUND(CASE 
                     WHEN p.stock_quantity < 0 THEN (ABS(p.stock_quantity) + pm.reorder_qty) * p.price
                     ELSE pm.reorder_qty * p.price 
-                END AS DECIMAL(15,3)) as replenish_retail,
+                END::numeric, 3) as replenish_retail,
                 pm.stock_status
             FROM products p
             JOIN product_metrics pm ON p.pid = pm.pid
@@ -234,10 +232,10 @@ router.get('/replenishment/metrics', async (req, res) => {
 
         // Format response
         const response = {
-            productsToReplenish: parseInt(metrics[0].products_to_replenish) || 0,
-            unitsToReplenish: parseInt(metrics[0].total_units_needed) || 0,
-            replenishmentCost: parseFloat(metrics[0].total_cost) || 0,
-            replenishmentRetail: parseFloat(metrics[0].total_retail) || 0,
+            productsToReplenish: parseInt(metrics.products_to_replenish) || 0,
+            unitsToReplenish: parseInt(metrics.total_units_needed) || 0,
+            replenishmentCost: parseFloat(metrics.total_cost) || 0,
+            replenishmentRetail: parseFloat(metrics.total_retail) || 0,
             topVariants: variants.map(v => ({
                 id: v.pid,
                 title: v.title,

inventory-server/src/routes/metrics.js

@@ -5,26 +5,28 @@ const router = express.Router();
 router.get('/trends', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
-    const [rows] = await pool.query(`
+    const { rows } = await pool.query(`
       WITH MonthlyMetrics AS (
         SELECT 
-          DATE(CONCAT(pta.year, '-', LPAD(pta.month, 2, '0'), '-01')) as date,
-          CAST(COALESCE(SUM(pta.total_revenue), 0) AS DECIMAL(15,3)) as revenue,
-          CAST(COALESCE(SUM(pta.total_cost), 0) AS DECIMAL(15,3)) as cost,
-          CAST(COALESCE(SUM(pm.inventory_value), 0) AS DECIMAL(15,3)) as inventory_value,
+          make_date(pta.year, pta.month, 1) as date,
+          ROUND(COALESCE(SUM(pta.total_revenue), 0)::numeric, 3) as revenue,
+          ROUND(COALESCE(SUM(pta.total_cost), 0)::numeric, 3) as cost,
+          ROUND(COALESCE(SUM(pm.inventory_value), 0)::numeric, 3) as inventory_value,
           CASE 
             WHEN SUM(pm.inventory_value) > 0 
-            THEN CAST((SUM(pta.total_revenue - pta.total_cost) / SUM(pm.inventory_value)) * 100 AS DECIMAL(15,3))
+            THEN ROUND((SUM(pta.total_revenue - pta.total_cost) / SUM(pm.inventory_value) * 100)::numeric, 3)
             ELSE 0 
           END as gmroi
         FROM product_time_aggregates pta
         JOIN product_metrics pm ON pta.pid = pm.pid
-        WHERE (pta.year * 100 + pta.month) >= DATE_FORMAT(DATE_SUB(CURDATE(), INTERVAL 12 MONTH), '%Y%m')
+        WHERE (pta.year * 100 + pta.month) >= 
+          EXTRACT(YEAR FROM CURRENT_DATE - INTERVAL '12 months')::integer * 100 + 
+          EXTRACT(MONTH FROM CURRENT_DATE - INTERVAL '12 months')::integer
         GROUP BY pta.year, pta.month
         ORDER BY date ASC
       )
       SELECT 
-        DATE_FORMAT(date, '%b %y') as date,
+        to_char(date, 'Mon YY') as date,
         revenue,
         inventory_value,
         gmroi

inventory-server/src/routes/orders.js

@@ -20,39 +20,46 @@ router.get('/', async (req, res) => {
     // Build the WHERE clause
     const conditions = ['o1.canceled = false'];
     const params = [];
+    let paramCounter = 1;
 
     if (search) {
-      conditions.push('(o1.order_number LIKE ? OR o1.customer LIKE ?)');
-      params.push(`%${search}%`, `%${search}%`);
+      conditions.push(`(o1.order_number ILIKE $${paramCounter} OR o1.customer ILIKE $${paramCounter})`);
+      params.push(`%${search}%`);
+      paramCounter++;
     }
 
     if (status !== 'all') {
-      conditions.push('o1.status = ?');
+      conditions.push(`o1.status = $${paramCounter}`);
       params.push(status);
+      paramCounter++;
     }
 
     if (fromDate) {
-      conditions.push('DATE(o1.date) >= DATE(?)');
+      conditions.push(`DATE(o1.date) >= DATE($${paramCounter})`);
       params.push(fromDate.toISOString());
+      paramCounter++;
     }
 
     if (toDate) {
-      conditions.push('DATE(o1.date) <= DATE(?)');
+      conditions.push(`DATE(o1.date) <= DATE($${paramCounter})`);
       params.push(toDate.toISOString());
+      paramCounter++;
     }
 
     if (minAmount > 0) {
-      conditions.push('total_amount >= ?');
+      conditions.push(`total_amount >= $${paramCounter}`);
       params.push(minAmount);
+      paramCounter++;
     }
 
     if (maxAmount) {
-      conditions.push('total_amount <= ?');
+      conditions.push(`total_amount <= $${paramCounter}`);
       params.push(maxAmount);
+      paramCounter++;
     }
 
     // Get total count for pagination
-    const [countResult] = await pool.query(`
+    const { rows: [countResult] } = await pool.query(`
       SELECT COUNT(DISTINCT o1.order_number) as total 
       FROM orders o1
       LEFT JOIN (
@@ -63,7 +70,7 @@ router.get('/', async (req, res) => {
       WHERE ${conditions.join(' AND ')}
     `, params);
     
-    const total = countResult[0].total;
+    const total = countResult.total;
 
     // Get paginated results
     const query = `
@@ -75,7 +82,7 @@ router.get('/', async (req, res) => {
         o1.payment_method,
         o1.shipping_method,
         COUNT(o2.pid) as items_count,
-        CAST(SUM(o2.price * o2.quantity) AS DECIMAL(15,3)) as total_amount
+        ROUND(SUM(o2.price * o2.quantity)::numeric, 3) as total_amount
       FROM orders o1
       JOIN orders o2 ON o1.order_number = o2.order_number
       WHERE ${conditions.join(' AND ')}
@@ -91,36 +98,37 @@ router.get('/', async (req, res) => {
           ? `${sortColumn} ${sortDirection}`
           : `o1.${sortColumn} ${sortDirection}`
       }
-      LIMIT ? OFFSET ?
+      LIMIT $${paramCounter} OFFSET $${paramCounter + 1}
     `;
 
-    const [rows] = await pool.query(query, [...params, limit, offset]);
+    params.push(limit, offset);
+    const { rows } = await pool.query(query, params);
 
     // Get order statistics
-    const [stats] = await pool.query(`
+    const { rows: [orderStats] } = await pool.query(`
       WITH CurrentStats AS (
         SELECT 
           COUNT(DISTINCT order_number) as total_orders,
-          CAST(SUM(price * quantity) AS DECIMAL(15,3)) as total_revenue
+          ROUND(SUM(price * quantity)::numeric, 3) as total_revenue
         FROM orders
         WHERE canceled = false
-          AND DATE(date) >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+          AND DATE(date) >= CURRENT_DATE - INTERVAL '30 days'
       ),
       PreviousStats AS (
         SELECT 
           COUNT(DISTINCT order_number) as prev_orders,
-          CAST(SUM(price * quantity) AS DECIMAL(15,3)) as prev_revenue
+          ROUND(SUM(price * quantity)::numeric, 3) as prev_revenue
         FROM orders
         WHERE canceled = false
-          AND DATE(date) BETWEEN DATE_SUB(CURDATE(), INTERVAL 60 DAY) AND DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+          AND DATE(date) BETWEEN CURRENT_DATE - INTERVAL '60 days' AND CURRENT_DATE - INTERVAL '30 days'
       ),
       OrderValues AS (
         SELECT 
           order_number,
-          CAST(SUM(price * quantity) AS DECIMAL(15,3)) as order_value
+          ROUND(SUM(price * quantity)::numeric, 3) as order_value
         FROM orders
         WHERE canceled = false
-          AND DATE(date) >= DATE_SUB(CURDATE(), INTERVAL 30 DAY)
+          AND DATE(date) >= CURRENT_DATE - INTERVAL '30 days'
         GROUP BY order_number
       )
       SELECT 
@@ -128,29 +136,27 @@ router.get('/', async (req, res) => {
         cs.total_revenue,
         CASE 
           WHEN ps.prev_orders > 0 
-          THEN ((cs.total_orders - ps.prev_orders) / ps.prev_orders * 100)
+          THEN ROUND(((cs.total_orders - ps.prev_orders)::numeric / ps.prev_orders * 100), 1)
           ELSE 0 
         END as order_growth,
         CASE 
           WHEN ps.prev_revenue > 0 
-          THEN ((cs.total_revenue - ps.prev_revenue) / ps.prev_revenue * 100)
+          THEN ROUND(((cs.total_revenue - ps.prev_revenue)::numeric / ps.prev_revenue * 100), 1)
           ELSE 0 
         END as revenue_growth,
         CASE 
           WHEN cs.total_orders > 0 
-          THEN CAST((cs.total_revenue / cs.total_orders) AS DECIMAL(15,3))
+          THEN ROUND((cs.total_revenue::numeric / cs.total_orders), 3)
           ELSE 0 
         END as average_order_value,
         CASE 
           WHEN ps.prev_orders > 0 
-          THEN CAST((ps.prev_revenue / ps.prev_orders) AS DECIMAL(15,3))
+          THEN ROUND((ps.prev_revenue::numeric / ps.prev_orders), 3)
           ELSE 0 
         END as prev_average_order_value
       FROM CurrentStats cs
       CROSS JOIN PreviousStats ps
     `);
-
-    const orderStats = stats[0];
     
     res.json({
       orders: rows.map(row => ({
@@ -189,7 +195,7 @@ router.get('/:orderNumber', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     // Get order details
-    const [orderRows] = await pool.query(`
+    const { rows: orderRows } = await pool.query(`
       SELECT DISTINCT
         o1.order_number,
         o1.customer,
@@ -200,10 +206,10 @@ router.get('/:orderNumber', async (req, res) => {
         o1.shipping_address,
         o1.billing_address,
         COUNT(o2.pid) as items_count,
-        CAST(SUM(o2.price * o2.quantity) AS DECIMAL(15,3)) as total_amount
+        ROUND(SUM(o2.price * o2.quantity)::numeric, 3) as total_amount
       FROM orders o1
       JOIN orders o2 ON o1.order_number = o2.order_number
-      WHERE o1.order_number = ? AND o1.canceled = false
+      WHERE o1.order_number = $1 AND o1.canceled = false
       GROUP BY 
         o1.order_number,
         o1.customer,
@@ -220,17 +226,17 @@ router.get('/:orderNumber', async (req, res) => {
     }
 
     // Get order items
-    const [itemRows] = await pool.query(`
+    const { rows: itemRows } = await pool.query(`
       SELECT 
         o.pid,
         p.title,
         p.SKU,
         o.quantity,
         o.price,
-        CAST((o.price * o.quantity) AS DECIMAL(15,3)) as total
+        ROUND((o.price * o.quantity)::numeric, 3) as total
       FROM orders o
       JOIN products p ON o.pid = p.pid
-      WHERE o.order_number = ? AND o.canceled = false
+      WHERE o.order_number = $1 AND o.canceled = false
     `, [req.params.orderNumber]);
 
     const order = {

inventory-server/src/routes/products.js

@@ -20,7 +20,7 @@ router.get('/brands', async (req, res) => {
         const pool = req.app.locals.pool;
         console.log('Fetching brands from database...');
         
-        const [results] = await pool.query(`
+        const { rows } = await pool.query(`
             SELECT DISTINCT COALESCE(p.brand, 'Unbranded') as brand
             FROM products p
             JOIN purchase_orders po ON p.pid = po.pid
@@ -30,8 +30,8 @@ router.get('/brands', async (req, res) => {
             ORDER BY COALESCE(p.brand, 'Unbranded')
         `);
         
-        console.log(`Found ${results.length} brands:`, results.slice(0, 3));
-        res.json(results.map(r => r.brand));
+        console.log(`Found ${rows.length} brands:`, rows.slice(0, 3));
+        res.json(rows.map(r => r.brand));
     } catch (error) {
         console.error('Error fetching brands:', error);
         res.status(500).json({ error: 'Failed to fetch brands' });
@@ -50,6 +50,7 @@ router.get('/', async (req, res) => {
 
     const conditions = ['p.visible = true'];
     const params = [];
+    let paramCounter = 1;
 
     // Add default replenishable filter unless explicitly showing non-replenishable
     if (req.query.showNonReplenishable !== 'true') {
@@ -58,9 +59,10 @@ router.get('/', async (req, res) => {
 
     // Handle search filter
     if (req.query.search) {
-      conditions.push('(p.title LIKE ? OR p.SKU LIKE ? OR p.barcode LIKE ?)');
+      conditions.push(`(p.title ILIKE $${paramCounter} OR p.SKU ILIKE $${paramCounter} OR p.barcode ILIKE $${paramCounter})`);
       const searchTerm = `%${req.query.search}%`;
-      params.push(searchTerm, searchTerm, searchTerm);
+      params.push(searchTerm);
+      paramCounter++;
     }
 
     // Handle numeric filters with operators
@@ -84,61 +86,69 @@ router.get('/', async (req, res) => {
       if (field) {
         const operator = req.query[`${key}_operator`] || '=';
         if (operator === 'between') {
-          // Handle between operator
           try {
             const [min, max] = JSON.parse(value);
-            conditions.push(`${field} BETWEEN ? AND ?`);
+            conditions.push(`${field} BETWEEN $${paramCounter} AND $${paramCounter + 1}`);
             params.push(min, max);
+            paramCounter += 2;
           } catch (e) {
             console.error(`Invalid between value for ${key}:`, value);
           }
         } else {
-          // Handle other operators
-          conditions.push(`${field} ${operator} ?`);
+          conditions.push(`${field} ${operator} $${paramCounter}`);
           params.push(parseFloat(value));
+          paramCounter++;
         }
       }
     });
 
     // Handle select filters
     if (req.query.vendor) {
-      conditions.push('p.vendor = ?');
+      conditions.push(`p.vendor = $${paramCounter}`);
       params.push(req.query.vendor);
+      paramCounter++;
     }
 
     if (req.query.brand) {
-      conditions.push('p.brand = ?');
+      conditions.push(`p.brand = $${paramCounter}`);
       params.push(req.query.brand);
+      paramCounter++;
     }
 
     if (req.query.category) {
-      conditions.push('p.categories LIKE ?');
+      conditions.push(`p.categories ILIKE $${paramCounter}`);
       params.push(`%${req.query.category}%`);
+      paramCounter++;
     }
 
     if (req.query.stockStatus && req.query.stockStatus !== 'all') {
-      conditions.push('pm.stock_status = ?');
+      conditions.push(`pm.stock_status = $${paramCounter}`);
       params.push(req.query.stockStatus);
+      paramCounter++;
     }
 
     if (req.query.abcClass) {
-      conditions.push('pm.abc_class = ?');
+      conditions.push(`pm.abc_class = $${paramCounter}`);
       params.push(req.query.abcClass);
+      paramCounter++;
     }
 
     if (req.query.leadTimeStatus) {
-      conditions.push('pm.lead_time_status = ?');
+      conditions.push(`pm.lead_time_status = $${paramCounter}`);
       params.push(req.query.leadTimeStatus);
+      paramCounter++;
     }
 
     if (req.query.replenishable !== undefined) {
-      conditions.push('p.replenishable = ?');
-      params.push(req.query.replenishable === 'true' ? 1 : 0);
+      conditions.push(`p.replenishable = $${paramCounter}`);
+      params.push(req.query.replenishable === 'true');
+      paramCounter++;
     }
 
     if (req.query.managingStock !== undefined) {
-      conditions.push('p.managing_stock = ?');
-      params.push(req.query.managingStock === 'true' ? 1 : 0);
+      conditions.push(`p.managing_stock = $${paramCounter}`);
+      params.push(req.query.managingStock === 'true');
+      paramCounter++;
     }
 
     // Combine all conditions with AND
@@ -151,17 +161,17 @@ router.get('/', async (req, res) => {
       LEFT JOIN product_metrics pm ON p.pid = pm.pid
       ${whereClause}
     `;
-    const [countResult] = await pool.query(countQuery, params);
-    const total = countResult[0].total;
+    const { rows: [countResult] } = await pool.query(countQuery, params);
+    const total = countResult.total;
 
     // Get available filters
-    const [categories] = await pool.query(
+    const { rows: categories } = await pool.query(
       'SELECT name FROM categories ORDER BY name'
     );
-    const [vendors] = await pool.query(
-      'SELECT DISTINCT vendor FROM products WHERE visible = true AND vendor IS NOT NULL AND vendor != "" ORDER BY vendor'
+    const { rows: vendors } = await pool.query(
+      'SELECT DISTINCT vendor FROM products WHERE visible = true AND vendor IS NOT NULL AND vendor != \'\' ORDER BY vendor'
     );
-    const [brands] = await pool.query(
+    const { rows: brands } = await pool.query(
       'SELECT DISTINCT COALESCE(brand, \'Unbranded\') as brand FROM products WHERE visible = true ORDER BY brand'
     );
 
@@ -173,7 +183,7 @@ router.get('/', async (req, res) => {
             c.cat_id,
             c.name,
             c.parent_id,
-            CAST(c.name AS CHAR(1000)) as path
+            CAST(c.name AS text) as path
           FROM categories c
           WHERE c.parent_id IS NULL
           
@@ -183,7 +193,7 @@ router.get('/', async (req, res) => {
             c.cat_id,
             c.name,
             c.parent_id,
-            CONCAT(cp.path, ' > ', c.name)
+            cp.path || ' > ' || c.name
           FROM categories c
           JOIN category_path cp ON c.parent_id = cp.cat_id
         ),
@@ -210,7 +220,6 @@ router.get('/', async (req, res) => {
           FROM products p
         ),
         product_leaf_categories AS (
-          -- Find categories that aren't parents to other categories for this product
           SELECT DISTINCT pc.cat_id
           FROM product_categories pc
           WHERE NOT EXISTS (
@@ -224,7 +233,7 @@ router.get('/', async (req, res) => {
       SELECT 
         p.*,
         COALESCE(p.brand, 'Unbranded') as brand,
-        GROUP_CONCAT(DISTINCT CONCAT(c.cat_id, ':', c.name)) as categories,
+        string_agg(DISTINCT (c.cat_id || ':' || c.name), ',') as categories,
         pm.daily_sales_avg,
         pm.weekly_sales_avg,
         pm.monthly_sales_avg,
@@ -247,83 +256,32 @@ router.get('/', async (req, res) => {
         pm.last_received_date,
         pm.abc_class,
         pm.stock_status,
-        pm.turnover_rate,
-        pm.current_lead_time,
-        pm.target_lead_time,
-        pm.lead_time_status,
-        pm.reorder_qty,
-        pm.overstocked_amt,
-        COALESCE(pm.days_of_inventory / NULLIF(pt.target_days, 0), 0) as stock_coverage_ratio
+        pm.turnover_rate
       FROM products p
       LEFT JOIN product_metrics pm ON p.pid = pm.pid
       LEFT JOIN product_categories pc ON p.pid = pc.pid
       LEFT JOIN categories c ON pc.cat_id = c.cat_id
-      LEFT JOIN product_thresholds pt ON p.pid = pt.pid
-      JOIN product_leaf_categories plc ON c.cat_id = plc.cat_id
-      ${whereClause ? 'WHERE ' + whereClause.substring(6) : ''}
-      GROUP BY p.pid
+      ${whereClause}
+      GROUP BY p.pid, pm.pid
       ORDER BY ${sortColumn} ${sortDirection}
-      LIMIT ? OFFSET ?
+      LIMIT $${paramCounter} OFFSET $${paramCounter + 1}
     `;
-
-    // Add pagination params to the main query params
-    const queryParams = [...params, limit, offset];
-    console.log('Query:', query.replace(/\s+/g, ' '));
-    console.log('Params:', queryParams);
-
-    const [rows] = await pool.query(query, queryParams);
-
-    // Transform the results
-    const products = rows.map(row => ({
-      ...row,
-      categories: row.categories ? row.categories.split(',') : [],
-      price: parseFloat(row.price),
-      cost_price: parseFloat(row.cost_price),
-      landing_cost_price: row.landing_cost_price ? parseFloat(row.landing_cost_price) : null,
-      stock_quantity: parseInt(row.stock_quantity),
-      daily_sales_avg: parseFloat(row.daily_sales_avg) || 0,
-      weekly_sales_avg: parseFloat(row.weekly_sales_avg) || 0,
-      monthly_sales_avg: parseFloat(row.monthly_sales_avg) || 0,
-      avg_quantity_per_order: parseFloat(row.avg_quantity_per_order) || 0,
-      number_of_orders: parseInt(row.number_of_orders) || 0,
-      first_sale_date: row.first_sale_date || null,
-      last_sale_date: row.last_sale_date || null,
-      days_of_inventory: parseFloat(row.days_of_inventory) || 0,
-      weeks_of_inventory: parseFloat(row.weeks_of_inventory) || 0,
-      reorder_point: parseFloat(row.reorder_point) || 0,
-      safety_stock: parseFloat(row.safety_stock) || 0,
-      avg_margin_percent: parseFloat(row.avg_margin_percent) || 0,
-      total_revenue: parseFloat(row.total_revenue) || 0,
-      inventory_value: parseFloat(row.inventory_value) || 0,
-      cost_of_goods_sold: parseFloat(row.cost_of_goods_sold) || 0,
-      gross_profit: parseFloat(row.gross_profit) || 0,
-      gmroi: parseFloat(row.gmroi) || 0,
-      avg_lead_time_days: parseFloat(row.avg_lead_time_days) || 0,
-      last_purchase_date: row.last_purchase_date || null,
-      last_received_date: row.last_received_date || null,
-      abc_class: row.abc_class || null,
-      stock_status: row.stock_status || null,
-      turnover_rate: parseFloat(row.turnover_rate) || 0,
-      current_lead_time: parseFloat(row.current_lead_time) || 0,
-      target_lead_time: parseFloat(row.target_lead_time) || 0,
-      lead_time_status: row.lead_time_status || null,
-      stock_coverage_ratio: parseFloat(row.stock_coverage_ratio) || 0,
-      reorder_qty: parseInt(row.reorder_qty) || 0,
-      overstocked_amt: parseInt(row.overstocked_amt) || 0
-    }));
+    
+    params.push(limit, offset);
+    const { rows: products } = await pool.query(query, params);
 
     res.json({
       products,
       pagination: {
         total,
-        currentPage: page,
         pages: Math.ceil(total / limit),
+        currentPage: page,
         limit
       },
       filters: {
-        categories: categories.map(category => category.name),
-        vendors: vendors.map(vendor => vendor.vendor),
-        brands: brands.map(brand => brand.brand)
+        categories: categories.map(c => c.name),
+        vendors: vendors.map(v => v.vendor),
+        brands: brands.map(b => b.brand)
       }
     });
   } catch (error) {

inventory-server/src/routes/purchase-orders.js

@@ -29,40 +29,46 @@ router.get('/', async (req, res) => {
     
     let whereClause = '1=1';
     const params = [];
+    let paramCounter = 1;
     
     if (search) {
-      whereClause += ' AND (po.po_id LIKE ? OR po.vendor LIKE ?)';
-      params.push(`%${search}%`, `%${search}%`);
+      whereClause += ` AND (po.po_id ILIKE $${paramCounter} OR po.vendor ILIKE $${paramCounter})`;
+      params.push(`%${search}%`);
+      paramCounter++;
     }
     
     if (status && status !== 'all') {
-      whereClause += ' AND po.status = ?';
+      whereClause += ` AND po.status = $${paramCounter}`;
       params.push(Number(status));
+      paramCounter++;
     }
     
     if (vendor && vendor !== 'all') {
-      whereClause += ' AND po.vendor = ?';
+      whereClause += ` AND po.vendor = $${paramCounter}`;
       params.push(vendor);
+      paramCounter++;
     }
     
     if (startDate) {
-      whereClause += ' AND po.date >= ?';
+      whereClause += ` AND po.date >= $${paramCounter}`;
       params.push(startDate);
+      paramCounter++;
     }
     
     if (endDate) {
-      whereClause += ' AND po.date <= ?';
+      whereClause += ` AND po.date <= $${paramCounter}`;
       params.push(endDate);
+      paramCounter++;
     }
 
     // Get filtered summary metrics
-    const [summary] = await pool.query(`
+    const { rows: [summary] } = await pool.query(`
       WITH po_totals AS (
         SELECT 
           po_id,
           SUM(ordered) as total_ordered,
           SUM(received) as total_received,
-          CAST(SUM(ordered * cost_price) AS DECIMAL(15,3)) as total_cost
+          ROUND(SUM(ordered * cost_price)::numeric, 3) as total_cost
         FROM purchase_orders po
         WHERE ${whereClause}
         GROUP BY po_id
@@ -72,26 +78,26 @@ router.get('/', async (req, res) => {
         SUM(total_ordered) as total_ordered,
         SUM(total_received) as total_received,
         ROUND(
-          SUM(total_received) / NULLIF(SUM(total_ordered), 0), 3
+          (SUM(total_received)::numeric / NULLIF(SUM(total_ordered), 0)), 3
         ) as fulfillment_rate,
-        CAST(SUM(total_cost) AS DECIMAL(15,3)) as total_value,
-        CAST(AVG(total_cost) AS DECIMAL(15,3)) as avg_cost
+        ROUND(SUM(total_cost)::numeric, 3) as total_value,
+        ROUND(AVG(total_cost)::numeric, 3) as avg_cost
       FROM po_totals
     `, params);
 
     // Get total count for pagination
-    const [countResult] = await pool.query(`
+    const { rows: [countResult] } = await pool.query(`
       SELECT COUNT(DISTINCT po_id) as total
       FROM purchase_orders po
       WHERE ${whereClause}
     `, params);
 
-    const total = countResult[0].total;
+    const total = countResult.total;
     const offset = (page - 1) * limit;
     const pages = Math.ceil(total / limit);
 
     // Get recent purchase orders
-    const [orders] = await pool.query(`
+    const { rows: orders } = await pool.query(`
       WITH po_totals AS (
         SELECT 
           po_id,
@@ -101,10 +107,10 @@ router.get('/', async (req, res) => {
           receiving_status,
           COUNT(DISTINCT pid) as total_items,
           SUM(ordered) as total_quantity,
-          CAST(SUM(ordered * cost_price) AS DECIMAL(15,3)) as total_cost,
+          ROUND(SUM(ordered * cost_price)::numeric, 3) as total_cost,
           SUM(received) as total_received,
           ROUND(
-            SUM(received) / NULLIF(SUM(ordered), 0), 3
+            (SUM(received)::numeric / NULLIF(SUM(ordered), 0)), 3
           ) as fulfillment_rate
         FROM purchase_orders po
         WHERE ${whereClause}
@@ -113,7 +119,7 @@ router.get('/', async (req, res) => {
       SELECT 
         po_id as id,
         vendor as vendor_name,
-        DATE_FORMAT(date, '%Y-%m-%d') as order_date,
+        to_char(date, 'YYYY-MM-DD') as order_date,
         status,
         receiving_status,
         total_items,
@@ -124,21 +130,21 @@ router.get('/', async (req, res) => {
       FROM po_totals
       ORDER BY 
         CASE 
-          WHEN ? = 'order_date' THEN date
-          WHEN ? = 'vendor_name' THEN vendor
-          WHEN ? = 'total_cost' THEN CAST(total_cost AS DECIMAL(15,3))
-          WHEN ? = 'total_received' THEN CAST(total_received AS DECIMAL(15,3))
-          WHEN ? = 'total_items' THEN CAST(total_items AS SIGNED)
-          WHEN ? = 'total_quantity' THEN CAST(total_quantity AS SIGNED)
-          WHEN ? = 'fulfillment_rate' THEN CAST(fulfillment_rate AS DECIMAL(5,3))
-          WHEN ? = 'status' THEN status
+          WHEN $${paramCounter} = 'order_date' THEN date
+          WHEN $${paramCounter} = 'vendor_name' THEN vendor
+          WHEN $${paramCounter} = 'total_cost' THEN total_cost
+          WHEN $${paramCounter} = 'total_received' THEN total_received
+          WHEN $${paramCounter} = 'total_items' THEN total_items
+          WHEN $${paramCounter} = 'total_quantity' THEN total_quantity
+          WHEN $${paramCounter} = 'fulfillment_rate' THEN fulfillment_rate
+          WHEN $${paramCounter} = 'status' THEN status
           ELSE date
         END ${sortDirection === 'desc' ? 'DESC' : 'ASC'}
-      LIMIT ? OFFSET ?
-    `, [...params, sortColumn, sortColumn, sortColumn, sortColumn, sortColumn, sortColumn, sortColumn, sortColumn, Number(limit), offset]);
+      LIMIT $${paramCounter + 1} OFFSET $${paramCounter + 2}
+    `, [...params, sortColumn, Number(limit), offset]);
 
     // Get unique vendors for filter options
-    const [vendors] = await pool.query(`
+    const { rows: vendors } = await pool.query(`
       SELECT DISTINCT vendor 
       FROM purchase_orders 
       WHERE vendor IS NOT NULL AND vendor != ''
@@ -146,7 +152,7 @@ router.get('/', async (req, res) => {
     `);
 
     // Get unique statuses for filter options
-    const [statuses] = await pool.query(`
+    const { rows: statuses } = await pool.query(`
       SELECT DISTINCT status 
       FROM purchase_orders 
       WHERE status IS NOT NULL
@@ -169,12 +175,12 @@ router.get('/', async (req, res) => {
 
     // Parse summary metrics
     const parsedSummary = {
-      order_count: Number(summary[0].order_count) || 0,
-      total_ordered: Number(summary[0].total_ordered) || 0,
-      total_received: Number(summary[0].total_received) || 0,
-      fulfillment_rate: Number(summary[0].fulfillment_rate) || 0,
-      total_value: Number(summary[0].total_value) || 0,
-      avg_cost: Number(summary[0].avg_cost) || 0
+      order_count: Number(summary.order_count) || 0,
+      total_ordered: Number(summary.total_ordered) || 0,
+      total_received: Number(summary.total_received) || 0,
+      fulfillment_rate: Number(summary.fulfillment_rate) || 0,
+      total_value: Number(summary.total_value) || 0,
+      avg_cost: Number(summary.avg_cost) || 0
     };
 
     res.json({
@@ -202,7 +208,7 @@ router.get('/vendor-metrics', async (req, res) => {
   try {
     const pool = req.app.locals.pool;
     
-    const [metrics] = await pool.query(`
+    const { rows: metrics } = await pool.query(`
       WITH delivery_metrics AS (
         SELECT 
           vendor,
@@ -213,7 +219,7 @@ router.get('/vendor-metrics', async (req, res) => {
           CASE 
             WHEN status >= ${STATUS.RECEIVING_STARTED} AND receiving_status >= ${RECEIVING_STATUS.PARTIAL_RECEIVED}
             AND received_date IS NOT NULL AND date IS NOT NULL
-            THEN DATEDIFF(received_date, date)
+            THEN (received_date - date)::integer
             ELSE NULL
           END as delivery_days
         FROM purchase_orders
@@ -226,18 +232,18 @@ router.get('/vendor-metrics', async (req, res) => {
         SUM(ordered) as total_ordered,
         SUM(received) as total_received,
         ROUND(
-          SUM(received) / NULLIF(SUM(ordered), 0), 3
+          (SUM(received)::numeric / NULLIF(SUM(ordered), 0)), 3
         ) as fulfillment_rate,
-        CAST(ROUND(
-          SUM(ordered * cost_price) / NULLIF(SUM(ordered), 0), 2
-        ) AS DECIMAL(15,3)) as avg_unit_cost,
-        CAST(SUM(ordered * cost_price) AS DECIMAL(15,3)) as total_spend,
         ROUND(
-          AVG(NULLIF(delivery_days, 0)), 1
+          (SUM(ordered * cost_price)::numeric / NULLIF(SUM(ordered), 0)), 2
+        ) as avg_unit_cost,
+        ROUND(SUM(ordered * cost_price)::numeric, 3) as total_spend,
+        ROUND(
+          AVG(NULLIF(delivery_days, 0))::numeric, 1
         ) as avg_delivery_days
       FROM delivery_metrics
       GROUP BY vendor
-      HAVING total_orders > 0
+      HAVING COUNT(DISTINCT po_id) > 0
       ORDER BY total_spend DESC
     `);
 
@@ -251,7 +257,7 @@ router.get('/vendor-metrics', async (req, res) => {
       fulfillment_rate: Number(vendor.fulfillment_rate) || 0,
       avg_unit_cost: Number(vendor.avg_unit_cost) || 0,
       total_spend: Number(vendor.total_spend) || 0,
-      avg_delivery_days: vendor.avg_delivery_days === null ? null : Number(vendor.avg_delivery_days)
+      avg_delivery_days: Number(vendor.avg_delivery_days) || 0
     }));
 
     res.json(parsedMetrics);

inventory-server/src/routes/templates.js

@@ -0,0 +1,283 @@
+const express = require('express');
+const { getPool } = require('../utils/db');
+const dotenv = require('dotenv');
+const path = require('path');
+
+dotenv.config({ path: path.join(__dirname, "../../.env") });
+
+const router = express.Router();
+
+// Get all templates
+router.get('/', async (req, res) => {
+  try {
+    const pool = getPool();
+    if (!pool) {
+      throw new Error('Database pool not initialized');
+    }
+    
+    const result = await pool.query(`
+      SELECT * FROM templates 
+      ORDER BY company ASC, product_type ASC
+    `);
+    res.json(result.rows);
+  } catch (error) {
+    console.error('Error fetching templates:', error);
+    res.status(500).json({ 
+      error: 'Failed to fetch templates',
+      details: error instanceof Error ? error.message : 'Unknown error'
+    });
+  }
+});
+
+// Get template by company and product type
+router.get('/:company/:productType', async (req, res) => {
+  try {
+    const { company, productType } = req.params;
+    const pool = getPool();
+    if (!pool) {
+      throw new Error('Database pool not initialized');
+    }
+    
+    const result = await pool.query(`
+      SELECT * FROM templates 
+      WHERE company = $1 AND product_type = $2
+    `, [company, productType]);
+
+    if (result.rows.length === 0) {
+      return res.status(404).json({ error: 'Template not found' });
+    }
+
+    res.json(result.rows[0]);
+  } catch (error) {
+    console.error('Error fetching template:', error);
+    res.status(500).json({ 
+      error: 'Failed to fetch template',
+      details: error instanceof Error ? error.message : 'Unknown error'
+    });
+  }
+});
+
+// Create new template
+router.post('/', async (req, res) => {
+  try {
+    const {
+      company,
+      product_type,
+      supplier,
+      msrp,
+      cost_each,
+      qty_per_unit,
+      case_qty,
+      hts_code,
+      description,
+      weight,
+      length,
+      width,
+      height,
+      tax_cat,
+      size_cat,
+      categories,
+      ship_restrictions
+    } = req.body;
+
+    // Validate required fields
+    if (!company || !product_type) {
+      return res.status(400).json({ error: 'Company and Product Type are required' });
+    }
+
+    const pool = getPool();
+    if (!pool) {
+      throw new Error('Database pool not initialized');
+    }
+    
+    const result = await pool.query(`
+      INSERT INTO templates (
+        company,
+        product_type,
+        supplier,
+        msrp,
+        cost_each,
+        qty_per_unit,
+        case_qty,
+        hts_code,
+        description,
+        weight,
+        length,
+        width,
+        height,
+        tax_cat,
+        size_cat,
+        categories,
+        ship_restrictions
+      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15, $16, $17)
+      RETURNING *
+    `, [
+      company,
+      product_type,
+      supplier,
+      msrp,
+      cost_each,
+      qty_per_unit,
+      case_qty,
+      hts_code,
+      description,
+      weight,
+      length,
+      width,
+      height,
+      tax_cat,
+      size_cat,
+      categories,
+      ship_restrictions
+    ]);
+
+    res.status(201).json(result.rows[0]);
+  } catch (error) {
+    console.error('Error creating template:', error);
+    // Check for unique constraint violation
+    if (error instanceof Error && error.message.includes('unique constraint')) {
+      return res.status(409).json({ 
+        error: 'Template already exists for this company and product type',
+        details: error.message
+      });
+    }
+    res.status(500).json({ 
+      error: 'Failed to create template',
+      details: error instanceof Error ? error.message : 'Unknown error'
+    });
+  }
+});
+
+// Update template
+router.put('/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const {
+      company,
+      product_type,
+      supplier,
+      msrp,
+      cost_each,
+      qty_per_unit,
+      case_qty,
+      hts_code,
+      description,
+      weight,
+      length,
+      width,
+      height,
+      tax_cat,
+      size_cat,
+      categories,
+      ship_restrictions
+    } = req.body;
+
+    // Validate required fields
+    if (!company || !product_type) {
+      return res.status(400).json({ error: 'Company and Product Type are required' });
+    }
+
+    const pool = getPool();
+    if (!pool) {
+      throw new Error('Database pool not initialized');
+    }
+    
+    const result = await pool.query(`
+      UPDATE templates 
+      SET 
+        company = $1,
+        product_type = $2,
+        supplier = $3,
+        msrp = $4,
+        cost_each = $5,
+        qty_per_unit = $6,
+        case_qty = $7,
+        hts_code = $8,
+        description = $9,
+        weight = $10,
+        length = $11,
+        width = $12,
+        height = $13,
+        tax_cat = $14,
+        size_cat = $15,
+        categories = $16,
+        ship_restrictions = $17
+      WHERE id = $18
+      RETURNING *
+    `, [
+      company,
+      product_type,
+      supplier,
+      msrp,
+      cost_each,
+      qty_per_unit,
+      case_qty,
+      hts_code,
+      description,
+      weight,
+      length,
+      width,
+      height,
+      tax_cat,
+      size_cat,
+      categories,
+      ship_restrictions,
+      id
+    ]);
+
+    if (result.rows.length === 0) {
+      return res.status(404).json({ error: 'Template not found' });
+    }
+
+    res.json(result.rows[0]);
+  } catch (error) {
+    console.error('Error updating template:', error);
+    // Check for unique constraint violation
+    if (error instanceof Error && error.message.includes('unique constraint')) {
+      return res.status(409).json({ 
+        error: 'Template already exists for this company and product type',
+        details: error.message
+      });
+    }
+    res.status(500).json({ 
+      error: 'Failed to update template',
+      details: error instanceof Error ? error.message : 'Unknown error'
+    });
+  }
+});
+
+// Delete template
+router.delete('/:id', async (req, res) => {
+  try {
+    const { id } = req.params;
+    const pool = getPool();
+    if (!pool) {
+      throw new Error('Database pool not initialized');
+    }
+    
+    const result = await pool.query('DELETE FROM templates WHERE id = $1 RETURNING *', [id]);
+
+    if (result.rows.length === 0) {
+      return res.status(404).json({ error: 'Template not found' });
+    }
+
+    res.json({ message: 'Template deleted successfully' });
+  } catch (error) {
+    console.error('Error deleting template:', error);
+    res.status(500).json({ 
+      error: 'Failed to delete template',
+      details: error instanceof Error ? error.message : 'Unknown error'
+    });
+  }
+});
+
+// Error handling middleware
+router.use((err, req, res, next) => {
+  console.error('Template route error:', err);
+  res.status(500).json({ 
+    error: 'Internal server error',
+    details: err.message
+  });
+});
+
+module.exports = router; 

inventory-server/src/routes/vendors.js

@@ -6,7 +6,7 @@ router.get('/', async (req, res) => {
   const pool = req.app.locals.pool;
   try {
     // Get all vendors with metrics
-    const [vendors] = await pool.query(`
+    const { rows: vendors } = await pool.query(`
       SELECT DISTINCT
         p.vendor as name,
         COALESCE(vm.active_products, 0) as active_products,
@@ -26,16 +26,16 @@ router.get('/', async (req, res) => {
 
     // Get cost metrics for all vendors
     const vendorNames = vendors.map(v => v.name);
-    const [costMetrics] = await pool.query(`
+    const { rows: costMetrics } = await pool.query(`
       SELECT 
         vendor,
-        CAST(ROUND(SUM(ordered * cost_price) / NULLIF(SUM(ordered), 0), 2) AS DECIMAL(15,3)) as avg_unit_cost,
-        CAST(SUM(ordered * cost_price) AS DECIMAL(15,3)) as total_spend
+        ROUND((SUM(ordered * cost_price)::numeric / NULLIF(SUM(ordered), 0)), 2) as avg_unit_cost,
+        ROUND(SUM(ordered * cost_price)::numeric, 3) as total_spend
       FROM purchase_orders
       WHERE status = 'closed'
         AND cost_price IS NOT NULL
         AND ordered > 0
-        AND vendor IN (?)
+        AND vendor = ANY($1)
       GROUP BY vendor
     `, [vendorNames]);
 
@@ -49,26 +49,26 @@ router.get('/', async (req, res) => {
     }, {});
 
     // Get overall stats
-    const [stats] = await pool.query(`
+    const { rows: [stats] } = await pool.query(`
       SELECT 
         COUNT(DISTINCT p.vendor) as totalVendors,
         COUNT(DISTINCT CASE 
           WHEN COALESCE(vm.total_orders, 0) > 0 AND COALESCE(vm.order_fill_rate, 0) >= 75 
           THEN p.vendor 
         END) as activeVendors,
-        COALESCE(ROUND(AVG(NULLIF(vm.avg_lead_time_days, 0)), 1), 0) as avgLeadTime,
-        COALESCE(ROUND(AVG(NULLIF(vm.order_fill_rate, 0)), 1), 0) as avgFillRate,
-        COALESCE(ROUND(AVG(NULLIF(vm.on_time_delivery_rate, 0)), 1), 0) as avgOnTimeDelivery
+        COALESCE(ROUND(AVG(NULLIF(vm.avg_lead_time_days, 0))::numeric, 1), 0) as avgLeadTime,
+        COALESCE(ROUND(AVG(NULLIF(vm.order_fill_rate, 0))::numeric, 1), 0) as avgFillRate,
+        COALESCE(ROUND(AVG(NULLIF(vm.on_time_delivery_rate, 0))::numeric, 1), 0) as avgOnTimeDelivery
       FROM products p
       LEFT JOIN vendor_metrics vm ON p.vendor = vm.vendor
       WHERE p.vendor IS NOT NULL AND p.vendor != ''
     `);
 
     // Get overall cost metrics
-    const [overallCostMetrics] = await pool.query(`
+    const { rows: [overallCostMetrics] } = await pool.query(`
       SELECT 
-        CAST(ROUND(SUM(ordered * cost_price) / NULLIF(SUM(ordered), 0), 2) AS DECIMAL(15,3)) as avg_unit_cost,
-        CAST(SUM(ordered * cost_price) AS DECIMAL(15,3)) as total_spend
+        ROUND((SUM(ordered * cost_price)::numeric / NULLIF(SUM(ordered), 0)), 2) as avg_unit_cost,
+        ROUND(SUM(ordered * cost_price)::numeric, 3) as total_spend
       FROM purchase_orders
       WHERE status = 'closed'
         AND cost_price IS NOT NULL
@@ -90,13 +90,13 @@ router.get('/', async (req, res) => {
         total_spend: parseFloat(costMetricsMap[vendor.name]?.total_spend || 0)
       })),
       stats: {
-        totalVendors: parseInt(stats[0].totalVendors),
-        activeVendors: parseInt(stats[0].activeVendors),
-        avgLeadTime: parseFloat(stats[0].avgLeadTime),
-        avgFillRate: parseFloat(stats[0].avgFillRate),
-        avgOnTimeDelivery: parseFloat(stats[0].avgOnTimeDelivery),
-        avgUnitCost: parseFloat(overallCostMetrics[0].avg_unit_cost),
-        totalSpend: parseFloat(overallCostMetrics[0].total_spend)
+        totalVendors: parseInt(stats.totalvendors),
+        activeVendors: parseInt(stats.activevendors),
+        avgLeadTime: parseFloat(stats.avgleadtime),
+        avgFillRate: parseFloat(stats.avgfillrate),
+        avgOnTimeDelivery: parseFloat(stats.avgontimedelivery),
+        avgUnitCost: parseFloat(overallCostMetrics.avg_unit_cost),
+        totalSpend: parseFloat(overallCostMetrics.total_spend)
       }
     });
   } catch (error) {

inventory-server/src/server.js

@@ -3,7 +3,6 @@ const cors = require('cors');
 const { spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
-const mysql = require('mysql2/promise');
 const { corsMiddleware, corsErrorHandler } = require('./middleware/cors');
 const { initPool } = require('./utils/db');
 const productsRouter = require('./routes/products');
@@ -16,11 +15,12 @@ const configRouter = require('./routes/config');
 const metricsRouter = require('./routes/metrics');
 const vendorsRouter = require('./routes/vendors');
 const categoriesRouter = require('./routes/categories');
-const testConnectionRouter = require('./routes/test-connection');
+const importRouter = require('./routes/import');
+const aiValidationRouter = require('./routes/ai-validation');
+const templatesRouter = require('./routes/templates');
 
 // Get the absolute path to the .env file
-const envPath = path.resolve(process.cwd(), '.env');
-console.log('Current working directory:', process.cwd());
+const envPath = '/var/www/html/inventory/.env';
 console.log('Looking for .env file at:', envPath);
 console.log('.env file exists:', fs.existsSync(envPath));
 
@@ -33,6 +33,9 @@ try {
     DB_HOST: process.env.DB_HOST || 'not set',
     DB_USER: process.env.DB_USER || 'not set',
     DB_NAME: process.env.DB_NAME || 'not set',
+    DB_PASSWORD: process.env.DB_PASSWORD ? '[password set]' : 'not set',
+    DB_PORT: process.env.DB_PORT || 'not set',
+    DB_SSL: process.env.DB_SSL || 'not set'
   });
 } catch (error) {
   console.error('Error loading .env file:', error);
@@ -62,61 +65,78 @@ app.use((req, res, next) => {
 app.use(corsMiddleware);
 
 // Body parser middleware
-app.use(express.json());
-app.use(express.urlencoded({ extended: true }));
+app.use(express.json({ limit: '10mb' }));
+app.use(express.urlencoded({ extended: true, limit: '10mb' }));
 
-// Initialize database pool
-const pool = initPool({
-  host: process.env.DB_HOST,
-  user: process.env.DB_USER,
-  password: process.env.DB_PASSWORD,
-  database: process.env.DB_NAME,
-  waitForConnections: true,
-  connectionLimit: process.env.NODE_ENV === 'production' ? 20 : 10,
-  queueLimit: 0,
-  enableKeepAlive: true,
-  keepAliveInitialDelay: 0
-});
+// Initialize database pool and start server
+async function startServer() {
+  try {
+    // Initialize database pool
+    const pool = await initPool({
+      host: process.env.DB_HOST,
+      user: process.env.DB_USER,
+      password: process.env.DB_PASSWORD,
+      database: process.env.DB_NAME,
+      port: process.env.DB_PORT || 5432,
+      max: process.env.NODE_ENV === 'production' ? 20 : 10,
+      idleTimeoutMillis: 30000,
+      connectionTimeoutMillis: 2000,
+      ssl: process.env.DB_SSL === 'true' ? {
+        rejectUnauthorized: false
+      } : false
+    });
 
-// Make pool available to routes
-app.locals.pool = pool;
+    // Make pool available to routes
+    app.locals.pool = pool;
 
-// Routes
-app.use('/api/products', productsRouter);
-app.use('/api/dashboard', dashboardRouter);
-app.use('/api/orders', ordersRouter);
-app.use('/api/csv', csvRouter);
-app.use('/api/analytics', analyticsRouter);
-app.use('/api/purchase-orders', purchaseOrdersRouter);
-app.use('/api/config', configRouter);
-app.use('/api/metrics', metricsRouter);
-app.use('/api/vendors', vendorsRouter);
-app.use('/api/categories', categoriesRouter);
-app.use('/api', testConnectionRouter);
+    // Set up routes after pool is initialized
+    app.use('/api/products', productsRouter);
+    app.use('/api/dashboard', dashboardRouter);
+    app.use('/api/orders', ordersRouter);
+    app.use('/api/csv', csvRouter);
+    app.use('/api/analytics', analyticsRouter);
+    app.use('/api/purchase-orders', purchaseOrdersRouter);
+    app.use('/api/config', configRouter);
+    app.use('/api/metrics', metricsRouter);
+    app.use('/api/vendors', vendorsRouter);
+    app.use('/api/categories', categoriesRouter);
+    app.use('/api/import', importRouter);
+    app.use('/api/ai-validation', aiValidationRouter);
+    app.use('/api/templates', templatesRouter);
 
-// Basic health check route
-app.get('/health', (req, res) => {
-  res.json({ 
-    status: 'ok',
-    timestamp: new Date().toISOString(),
-    environment: process.env.NODE_ENV
-  });
-});
+    // Basic health check route
+    app.get('/health', (req, res) => {
+      res.json({ 
+        status: 'ok',
+        timestamp: new Date().toISOString(),
+        environment: process.env.NODE_ENV
+      });
+    });
 
-// CORS error handler - must be before other error handlers
-app.use(corsErrorHandler);
+    // CORS error handler - must be before other error handlers
+    app.use(corsErrorHandler);
 
-// Error handling middleware - MUST be after routes and CORS error handler
-app.use((err, req, res, next) => {
-  console.error(`[${new Date().toISOString()}] Error:`, err);
-  
-  // Send detailed error in development, generic in production
-  const error = process.env.NODE_ENV === 'production'
-    ? 'An internal server error occurred'
-    : err.message || err;
-    
-  res.status(err.status || 500).json({ error });
-});
+    // Error handling middleware - MUST be after routes and CORS error handler
+    app.use((err, req, res, next) => {
+      console.error(`[${new Date().toISOString()}] Error:`, err);
+      
+      // Send detailed error in development, generic in production
+      const error = process.env.NODE_ENV === 'production'
+        ? 'An internal server error occurred'
+        : err.message || err;
+        
+      res.status(err.status || 500).json({ error });
+    });
+
+    const PORT = process.env.PORT || 3000;
+    app.listen(PORT, () => {
+      console.log(`[Server] Running in ${process.env.NODE_ENV || 'development'} mode on port ${PORT}`);
+    });
+  } catch (error) {
+    console.error('Failed to start server:', error);
+    process.exit(1);
+  }
+}
 
 // Handle uncaught exceptions
 process.on('uncaughtException', (err) => {
@@ -128,17 +148,6 @@ process.on('unhandledRejection', (reason, promise) => {
   console.error(`[${new Date().toISOString()}] Unhandled Rejection at:`, promise, 'reason:', reason);
 });
 
-// Test database connection
-pool.getConnection()
-  .then(connection => {
-    console.log('[Database] Connected successfully');
-    connection.release();
-  })
-  .catch(err => {
-    console.error('[Database] Error connecting:', err);
-    process.exit(1);
-  });
-
 // Initialize client sets for SSE
 const importClients = new Set();
 const updateClients = new Set();
@@ -189,62 +198,5 @@ const setupSSE = (req, res) => {
   }
 };
 
-// Update the status endpoint to include reset-metrics
-app.get('/csv/status', (req, res) => {
-    res.json({
-        active: !!currentOperation,
-        type: currentOperation?.type || null,
-        progress: currentOperation ? {
-            status: currentOperation.status,
-            operation: currentOperation.operation,
-            current: currentOperation.current,
-            total: currentOperation.total,
-            percentage: currentOperation.percentage
-        } : null
-    });
-});
-
-// Update progress endpoint mapping
-app.get('/csv/:type/progress', (req, res) => {
-    const { type } = req.params;
-    if (!['import', 'update', 'reset', 'reset-metrics'].includes(type)) {
-        res.status(400).json({ error: 'Invalid operation type' });
-        return;
-    }
-
-    setupSSE(req, res);
-});
-
-// Update the cancel endpoint to handle reset-metrics
-app.post('/csv/cancel', (req, res) => {
-    const { operation } = req.query;
-    
-    if (!currentOperation) {
-        res.status(400).json({ error: 'No operation in progress' });
-        return;
-    }
-
-    if (operation && operation.toLowerCase() !== currentOperation.type) {
-        res.status(400).json({ error: 'Operation type mismatch' });
-        return;
-    }
-
-    try {
-        // Handle cancellation based on operation type
-        if (currentOperation.type === 'reset-metrics') {
-            // Reset metrics doesn't need special cleanup
-            currentOperation = null;
-            res.json({ message: 'Reset metrics cancelled' });
-        } else {
-            // ... existing cancellation logic for other operations ...
-        }
-    } catch (error) {
-        console.error('Error during cancellation:', error);
-        res.status(500).json({ error: 'Failed to cancel operation' });
-    }
-});
-
-const PORT = process.env.PORT || 3000;
-app.listen(PORT, () => {
-  console.log(`[Server] Running in ${process.env.NODE_ENV || 'development'} mode on port ${PORT}`);
-}); 
+// Start the server
+startServer(); 

inventory-server/src/utils/db.js

@@ -1,17 +1,54 @@
-const mysql = require('mysql2/promise');
+const { Pool, Client } = require('pg');
+const { Client: SSHClient } = require('ssh2');
 
 let pool;
 
 function initPool(config) {
-  pool = mysql.createPool(config);
-  return pool;
+  // Log config without sensitive data
+  const safeConfig = {
+    host: config.host || process.env.DB_HOST,
+    user: config.user || process.env.DB_USER,
+    database: config.database || process.env.DB_NAME,
+    port: config.port || process.env.DB_PORT || 5432,
+    max: config.max || 10,
+    idleTimeoutMillis: config.idleTimeoutMillis || 30000,
+    connectionTimeoutMillis: config.connectionTimeoutMillis || 2000,
+    ssl: config.ssl || false,
+    password: (config.password || process.env.DB_PASSWORD) ? '[password set]' : '[no password]'
+  };
+  console.log('[Database] Initializing pool with config:', safeConfig);
+  
+  // Create the pool with the configuration
+  pool = new Pool({
+    host: config.host || process.env.DB_HOST,
+    user: config.user || process.env.DB_USER,
+    password: config.password || process.env.DB_PASSWORD,
+    database: config.database || process.env.DB_NAME,
+    port: config.port || process.env.DB_PORT || 5432,
+    max: config.max || 10,
+    idleTimeoutMillis: config.idleTimeoutMillis || 30000,
+    connectionTimeoutMillis: config.connectionTimeoutMillis || 2000,
+    ssl: config.ssl || false
+  });
+
+  // Test the pool connection
+  return pool.connect()
+    .then(client => {
+      console.log('[Database] Pool connection successful');
+      client.release();
+      return pool;
+    })
+    .catch(err => {
+      console.error('[Database] Connection failed:', err);
+      throw err;
+    });
 }
 
 async function getConnection() {
   if (!pool) {
     throw new Error('Database pool not initialized');
   }
-  return pool.getConnection();
+  return pool.connect();
 }
 
 module.exports = {

inventory/package.json

@@ -10,58 +10,92 @@
     "preview": "vite preview"
   },
   "dependencies": {
+    "@chakra-ui/button": "^2.1.0",
+    "@chakra-ui/checkbox": "^2.3.2",
+    "@chakra-ui/form-control": "^2.2.0",
+    "@chakra-ui/hooks": "^2.4.3",
+    "@chakra-ui/icons": "^2.2.4",
+    "@chakra-ui/input": "^2.1.2",
+    "@chakra-ui/layout": "^2.3.1",
+    "@chakra-ui/modal": "^2.3.1",
+    "@chakra-ui/popper": "^3.1.0",
+    "@chakra-ui/react": "^2.8.1",
+    "@chakra-ui/select": "^2.1.2",
+    "@chakra-ui/system": "^2.6.2",
+    "@chakra-ui/theme": "^3.4.7",
+    "@chakra-ui/theme-tools": "^2.2.7",
+    "@chakra-ui/utils": "^2.2.3",
     "@dnd-kit/core": "^6.3.1",
     "@dnd-kit/sortable": "^10.0.0",
     "@dnd-kit/utilities": "^3.2.2",
+    "@emotion/react": "^11.14.0",
+    "@emotion/styled": "^11.14.0",
     "@radix-ui/react-accordion": "^1.2.2",
     "@radix-ui/react-alert-dialog": "^1.1.4",
     "@radix-ui/react-avatar": "^1.1.2",
+    "@radix-ui/react-checkbox": "^1.1.4",
     "@radix-ui/react-collapsible": "^1.1.2",
-    "@radix-ui/react-dialog": "^1.1.4",
+    "@radix-ui/react-dialog": "^1.1.6",
     "@radix-ui/react-dropdown-menu": "^2.1.4",
     "@radix-ui/react-label": "^2.1.1",
-    "@radix-ui/react-popover": "^1.1.4",
+    "@radix-ui/react-popover": "^1.1.6",
     "@radix-ui/react-progress": "^1.1.1",
+    "@radix-ui/react-radio-group": "^1.2.3",
     "@radix-ui/react-scroll-area": "^1.2.2",
     "@radix-ui/react-select": "^2.1.4",
     "@radix-ui/react-separator": "^1.1.1",
-    "@radix-ui/react-slot": "^1.1.1",
+    "@radix-ui/react-slot": "^1.1.2",
     "@radix-ui/react-switch": "^1.1.2",
     "@radix-ui/react-tabs": "^1.1.2",
+    "@radix-ui/react-toast": "^1.2.6",
     "@radix-ui/react-toggle": "^1.1.1",
     "@radix-ui/react-toggle-group": "^1.1.1",
     "@radix-ui/react-tooltip": "^1.1.6",
     "@shadcn/ui": "^0.0.4",
     "@tabler/icons-react": "^3.28.1",
-    "@tanstack/react-query": "^5.63.0",
+    "@tanstack/react-query": "^5.66.7",
     "@tanstack/react-table": "^8.20.6",
     "@tanstack/react-virtual": "^3.11.2",
     "@tanstack/virtual-core": "^3.11.2",
+    "@types/js-levenshtein": "^1.1.3",
+    "@types/uuid": "^10.0.0",
+    "axios": "^1.8.1",
+    "chakra-react-select": "^4.7.5",
+    "chakra-ui-steps": "^2.0.4",
     "chart.js": "^4.4.7",
     "chartjs-adapter-date-fns": "^3.0.0",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "cmdk": "^1.0.0",
     "date-fns": "^3.6.0",
+    "diff": "^7.0.0",
+    "framer-motion": "^12.4.4",
+    "js-levenshtein": "^1.1.6",
+    "lodash": "^4.17.21",
     "lucide-react": "^0.469.0",
     "motion": "^11.18.0",
     "next-themes": "^0.4.4",
     "react": "^18.3.1",
     "react-chartjs-2": "^5.3.0",
+    "react-data-grid": "^7.0.0-beta.13",
     "react-day-picker": "^8.10.1",
     "react-dom": "^18.3.1",
+    "react-dropzone": "^14.3.5",
+    "react-icons": "^5.4.0",
     "react-router-dom": "^7.1.1",
     "recharts": "^2.15.0",
     "sonner": "^1.7.1",
     "tailwind-merge": "^2.6.0",
     "tailwindcss-animate": "^1.0.7",
     "tanstack": "^1.0.0",
-    "vaul": "^1.1.2"
+    "uuid": "^11.0.5",
+    "vaul": "^1.1.2",
+    "xlsx": "^0.18.5"
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
     "@types/fs-extra": "^11.0.4",
-    "@types/lodash": "^4.17.14",
+    "@types/lodash": "^4.17.15",
     "@types/node": "^22.10.5",
     "@types/react": "^18.3.18",
     "@types/react-dom": "^18.3.5",

inventory/src/App.tsx

@@ -15,6 +15,9 @@ import { RequireAuth } from './components/auth/RequireAuth';
 import Forecasting from "@/pages/Forecasting";
 import { Vendors } from '@/pages/Vendors';
 import { Categories } from '@/pages/Categories';
+import { Import } from '@/pages/Import';
+import { ChakraProvider } from '@chakra-ui/react';
+import { AiValidationDebug } from "@/pages/AiValidationDebug"
 
 const queryClient = new QueryClient();
 
@@ -50,26 +53,30 @@ function App() {
 
   return (
     <QueryClientProvider client={queryClient}>
-      <Toaster richColors position="top-center" />
-      <Routes>
-        <Route path="/login" element={<Login />} />
-        <Route element={
-          <RequireAuth>
-            <MainLayout />
-          </RequireAuth>
-        }>
-          <Route path="/" element={<Dashboard />} />
-          <Route path="/products" element={<Products />} />
-          <Route path="/categories" element={<Categories />} />
-          <Route path="/vendors" element={<Vendors />} />
-          <Route path="/orders" element={<Orders />} />
-          <Route path="/purchase-orders" element={<PurchaseOrders />} />
-          <Route path="/analytics" element={<Analytics />} />
-          <Route path="/settings" element={<Settings />} />
-          <Route path="/forecasting" element={<Forecasting />} />
-          <Route path="*" element={<Navigate to="/" replace />} />
-        </Route>
-      </Routes>
+      <ChakraProvider>
+        <Toaster richColors position="top-center" />
+        <Routes>
+          <Route path="/login" element={<Login />} />
+          <Route element={
+            <RequireAuth>
+              <MainLayout />
+            </RequireAuth>
+          }>
+            <Route path="/" element={<Dashboard />} />
+            <Route path="/products" element={<Products />} />
+            <Route path="/import" element={<Import />} />
+            <Route path="/categories" element={<Categories />} />
+            <Route path="/vendors" element={<Vendors />} />
+            <Route path="/orders" element={<Orders />} />
+            <Route path="/purchase-orders" element={<PurchaseOrders />} />
+            <Route path="/analytics" element={<Analytics />} />
+            <Route path="/settings" element={<Settings />} />
+            <Route path="/forecasting" element={<Forecasting />} />
+            <Route path="/ai-validation/debug" element={<AiValidationDebug />} />
+            <Route path="*" element={<Navigate to="/" replace />} />
+          </Route>
+        </Routes>
+      </ChakraProvider>
     </QueryClientProvider>
   );
 }

inventory/src/components/layout/AppSidebar.tsx

@@ -8,6 +8,7 @@ import {
   LogOut,
   Users,
   Tags,
+  FileSpreadsheet,
 } from "lucide-react";
 import { IconCrystalBall } from "@tabler/icons-react";
 import {
@@ -35,6 +36,11 @@ const items = [
     icon: Package,
     url: "/products",
   },
+  {
+    title: "Import",
+    icon: FileSpreadsheet,
+    url: "/import",
+  },
   {
     title: "Forecasting",
     icon: IconCrystalBall,

inventory/src/components/settings/DataManagement.tsx

@@ -27,7 +27,7 @@ import {
 import { Loader2, X, RefreshCw, AlertTriangle, RefreshCcw, Hourglass } from "lucide-react";
 import config from "../../config";
 import { toast } from "sonner";
-import { Table, TableBody, TableCell, TableRow, TableHeader, TableHead } from "@/components/ui/table";
+import { Table, TableBody, TableCell, TableRow } from "@/components/ui/table";
 
 interface ImportProgress {
   status: "running" | "error" | "complete" | "cancelled";
@@ -85,9 +85,7 @@ export function DataManagement() {
   const [] = useState<ImportProgress | null>(null);
   const [eventSource, setEventSource] = useState<EventSource | null>(null);
   const [importHistory, setImportHistory] = useState<ImportHistoryRecord[]>([]);
-  const [calculateHistory, setCalculateHistory] = useState<
-    CalculateHistoryRecord[]
-  >([]);
+  const [calculateHistory, setCalculateHistory] = useState<CalculateHistoryRecord[]>([]);
   const [moduleStatus, setModuleStatus] = useState<ModuleStatus[]>([]);
   const [tableStatus, setTableStatus] = useState<TableStatus[]>([]);
   const [scriptOutput, setScriptOutput] = useState<string[]>([]);
@@ -368,6 +366,10 @@ export function DataManagement() {
         fetch(`${config.apiUrl}/csv/status/tables`),
       ]);
 
+      if (!importRes.ok || !calcRes.ok || !moduleRes.ok || !tableRes.ok) {
+        throw new Error('One or more requests failed');
+      }
+
       const [importData, calcData, moduleData, tableData] = await Promise.all([
         importRes.json(),
         calcRes.json(),
@@ -375,52 +377,66 @@ export function DataManagement() {
         tableRes.json(),
       ]);
 
-      setImportHistory(importData);
-      setCalculateHistory(calcData);
-      setModuleStatus(moduleData);
-      setTableStatus(tableData);
+      // Ensure we're setting arrays even if the response is empty or invalid
+      setImportHistory(Array.isArray(importData) ? importData : []);
+      setCalculateHistory(Array.isArray(calcData) ? calcData : []);
+      setModuleStatus(Array.isArray(moduleData) ? moduleData : []);
+      setTableStatus(Array.isArray(tableData) ? tableData : []);
     } catch (error) {
       console.error("Error fetching history:", error);
+      // Set empty arrays as fallback
+      setImportHistory([]);
+      setCalculateHistory([]);
+      setModuleStatus([]);
+      setTableStatus([]);
     }
   };
 
   const refreshTableStatus = async () => {
     try {
       const response = await fetch(`${config.apiUrl}/csv/status/tables`);
+      if (!response.ok) throw new Error('Failed to fetch table status');
       const data = await response.json();
-      setTableStatus(data);
+      setTableStatus(Array.isArray(data) ? data : []);
     } catch (error) {
       toast.error("Failed to refresh table status");
+      setTableStatus([]);
     }
   };
 
   const refreshModuleStatus = async () => {
     try {
       const response = await fetch(`${config.apiUrl}/csv/status/modules`);
+      if (!response.ok) throw new Error('Failed to fetch module status');
       const data = await response.json();
-      setModuleStatus(data);
+      setModuleStatus(Array.isArray(data) ? data : []);
     } catch (error) {
       toast.error("Failed to refresh module status");
+      setModuleStatus([]);
     }
   };
 
   const refreshImportHistory = async () => {
     try {
       const response = await fetch(`${config.apiUrl}/csv/history/import`);
+      if (!response.ok) throw new Error('Failed to fetch import history');
       const data = await response.json();
-      setImportHistory(data);
+      setImportHistory(Array.isArray(data) ? data : []);
     } catch (error) {
       toast.error("Failed to refresh import history");
+      setImportHistory([]);
     }
   };
 
   const refreshCalculateHistory = async () => {
     try {
       const response = await fetch(`${config.apiUrl}/csv/history/calculate`);
+      if (!response.ok) throw new Error('Failed to fetch calculate history');
       const data = await response.json();
-      setCalculateHistory(data);
+      setCalculateHistory(Array.isArray(data) ? data : []);
     } catch (error) {
       toast.error("Failed to refresh calculate history");
+      setCalculateHistory([]);
     }
   };
 
@@ -660,75 +676,83 @@ export function DataManagement() {
           <CardContent className="px-4 mb-4 max-h-[300px] overflow-y-auto">
             <Table>
               <TableBody>
-                {importHistory.slice(0, 20).map((record) => (
-                  <TableRow key={record.id} className="hover:bg-transparent">
-                    <TableCell className="w-full p-0">
-                      <Accordion type="single" collapsible>
-                        <AccordionItem
-                          value={`import-${record.id}`}
-                          className="border-0"
-                        >
-                          <AccordionTrigger className="px-4 py-2">
-                            <div className="flex justify-between items-start w-full pr-4">
-                              <span className="font-medium min-w-[60px]">
-                                #{record.id}
-                              </span>
-                              <span className="text-sm text-gray-600 min-w-[120px]">
-                                {formatDate(record.start_time)}
-                              </span>
-                              <span className="text-sm min-w-[100px]">
-                                {formatDurationWithSeconds(
-                                  record.duration_minutes,
-                                  record.status === "running",
-                                  record.start_time
-                                )}
-                              </span>
-                              <span
-                                className={`min-w-[80px] ${
-                                  record.status === "completed"
-                                    ? "text-green-600"
-                                    : record.status === "failed"
-                                    ? "text-red-600"
-                                    : record.status === "cancelled"
-                                    ? "text-yellow-600"
-                                    : "text-blue-600"
-                                }`}
-                              >
-                                {record.status}
-                              </span>
-                            </div>
-                          </AccordionTrigger>
-                          <AccordionContent className="px-4 pb-2">
-                            <div className="space-y-2 pt-2">
-                              <div className="flex justify-between text-sm">
-                                <span className="text-gray-600">End Time:</span>
-                                <span>
-                                  {record.end_time
-                                    ? formatDate(record.end_time)
-                                    : "N/A"}
+                {importHistory.length > 0 ? (
+                  importHistory.slice(0, 20).map((record) => (
+                    <TableRow key={record.id} className="hover:bg-transparent">
+                      <TableCell className="w-full p-0">
+                        <Accordion type="single" collapsible>
+                          <AccordionItem
+                            value={`import-${record.id}`}
+                            className="border-0"
+                          >
+                            <AccordionTrigger className="px-4 py-2">
+                              <div className="flex justify-between items-start w-full pr-4">
+                                <span className="font-medium min-w-[60px]">
+                                  #{record.id}
+                                </span>
+                                <span className="text-sm text-gray-600 min-w-[120px]">
+                                  {formatDate(record.start_time)}
+                                </span>
+                                <span className="text-sm min-w-[100px]">
+                                  {formatDurationWithSeconds(
+                                    record.duration_minutes,
+                                    record.status === "running",
+                                    record.start_time
+                                  )}
+                                </span>
+                                <span
+                                  className={`min-w-[80px] ${
+                                    record.status === "completed"
+                                      ? "text-green-600"
+                                      : record.status === "failed"
+                                      ? "text-red-600"
+                                      : record.status === "cancelled"
+                                      ? "text-yellow-600"
+                                      : "text-blue-600"
+                                  }`}
+                                >
+                                  {record.status}
                                 </span>
                               </div>
-                              <div className="flex justify-between text-sm">
-                                <span className="text-gray-600">Records:</span>
-                                <span>
-                                  {record.records_added} added,{" "}
-                                  {record.records_updated} updated
-                                </span>
-                              </div>
-                              {record.error_message && (
-                                <div className="text-sm text-red-600 mt-2">
-                                  {record.error_message}
+                            </AccordionTrigger>
+                            <AccordionContent className="px-4 pb-2">
+                              <div className="space-y-2 pt-2">
+                                <div className="flex justify-between text-sm">
+                                  <span className="text-gray-600">End Time:</span>
+                                  <span>
+                                    {record.end_time
+                                      ? formatDate(record.end_time)
+                                      : "N/A"}
+                                  </span>
                                 </div>
-                              )}
-                              {record.additional_info &&
-                                formatJsonData(record.additional_info)}
-                            </div>
-                          </AccordionContent>
-                        </AccordionItem>
-                      </Accordion>
+                                <div className="flex justify-between text-sm">
+                                  <span className="text-gray-600">Records:</span>
+                                  <span>
+                                    {record.records_added} added,{" "}
+                                    {record.records_updated} updated
+                                  </span>
+                                </div>
+                                {record.error_message && (
+                                  <div className="text-sm text-red-600 mt-2">
+                                    {record.error_message}
+                                  </div>
+                                )}
+                                {record.additional_info &&
+                                  formatJsonData(record.additional_info)}
+                              </div>
+                            </AccordionContent>
+                          </AccordionItem>
+                        </Accordion>
+                      </TableCell>
+                    </TableRow>
+                  ))
+                ) : (
+                  <TableRow>
+                    <TableCell className="text-center text-sm text-muted-foreground py-4">
+                      No import history available
                     </TableCell>
                   </TableRow>
-                ))}
+                )}
               </TableBody>
             </Table>
           </CardContent>
@@ -742,90 +766,98 @@ export function DataManagement() {
           <CardContent className="px-4 mb-4 max-h-[300px] overflow-y-auto">
             <Table>
               <TableBody>
-                {calculateHistory.slice(0, 20).map((record) => (
-                  <TableRow key={record.id} className="hover:bg-transparent">
-                    <TableCell className="w-full p-0">
-                      <Accordion type="single" collapsible>
-                        <AccordionItem
-                          value={`calc-${record.id}`}
-                          className="border-0"
-                        >
-                          <AccordionTrigger className="px-4 py-2">
-                            <div className="flex justify-between items-start w-full pr-4">
-                              <span className="font-medium min-w-[60px]">
-                                #{record.id}
-                              </span>
-                              <span className="text-sm text-gray-600 min-w-[120px]">
-                                {formatDate(record.start_time)}
-                              </span>
-                              <span className="text-sm min-w-[100px]">
-                                {formatDurationWithSeconds(
-                                  record.duration_minutes,
-                                  record.status === "running",
-                                  record.start_time
-                                )}
-                              </span>
+                {calculateHistory.length > 0 ? (
+                  calculateHistory.slice(0, 20).map((record) => (
+                    <TableRow key={record.id} className="hover:bg-transparent">
+                      <TableCell className="w-full p-0">
+                        <Accordion type="single" collapsible>
+                          <AccordionItem
+                            value={`calc-${record.id}`}
+                            className="border-0"
+                          >
+                            <AccordionTrigger className="px-4 py-2">
+                              <div className="flex justify-between items-start w-full pr-4">
+                                <span className="font-medium min-w-[60px]">
+                                  #{record.id}
+                                </span>
+                                <span className="text-sm text-gray-600 min-w-[120px]">
+                                  {formatDate(record.start_time)}
+                                </span>
+                                <span className="text-sm min-w-[100px]">
+                                  {formatDurationWithSeconds(
+                                    record.duration_minutes,
+                                    record.status === "running",
+                                    record.start_time
+                                  )}
+                                </span>
 
-                              <span
-                                className={`min-w-[80px] ${ 
-                                  record.status === "completed"
-                                    ? "text-green-600"
-                                    : record.status === "failed"
-                                    ? "text-red-600"
-                                    : record.status === "cancelled"
-                                    ? "text-yellow-600"
-                                    : "text-blue-600"
-                                }`}
-                              >
-                                {record.status}
-                              </span>
-                            </div>
-                          </AccordionTrigger>
-                          <AccordionContent className="px-4 pb-2">
-                            <div className="space-y-2 pt-2">
-                              <div className="flex justify-between text-sm">
-                                <span className="text-gray-600">End Time:</span>
-                                <span>
-                                  {record.end_time
-                                    ? formatDate(record.end_time)
-                                    : "N/A"}
+                                <span
+                                  className={`min-w-[80px] ${ 
+                                    record.status === "completed"
+                                      ? "text-green-600"
+                                      : record.status === "failed"
+                                      ? "text-red-600"
+                                      : record.status === "cancelled"
+                                      ? "text-yellow-600"
+                                      : "text-blue-600"
+                                  }`}
+                                >
+                                  {record.status}
                                 </span>
                               </div>
-                              <div className="flex justify-between text-sm">
-                                <span className="text-gray-600">
-                                  Processed Products:
-                                </span>
-                                <span>{record.processed_products}</span>
+                            </AccordionTrigger>
+                            <AccordionContent className="px-4 pb-2">
+                              <div className="space-y-2 pt-2">
+                                <div className="flex justify-between text-sm">
+                                  <span className="text-gray-600">End Time:</span>
+                                  <span>
+                                    {record.end_time
+                                      ? formatDate(record.end_time)
+                                      : "N/A"}
+                                  </span>
+                                </div>
+                                <div className="flex justify-between text-sm">
+                                  <span className="text-gray-600">
+                                    Processed Products:
+                                  </span>
+                                  <span>{record.processed_products}</span>
+                                </div>
+                                <div className="flex justify-between text-sm">
+                                  <span className="text-gray-600">
+                                    Processed Orders:
+                                  </span>
+                                  <span>{record.processed_orders}</span>
+                                </div>
+                                <div className="flex justify-between text-sm">
+                                  <span className="text-gray-600">
+                                    Processed Purchase Orders:
+                                  </span>
+                                  <span>{record.processed_purchase_orders}</span>
+                                </div>
+                                {record.error_message && (
+                                  <div className="text-sm text-red-600 mt-2">
+                                    {record.error_message}
+              </div>
+            )}
+                                {record.additional_info &&
+                                  formatJsonData(record.additional_info)}
                               </div>
-                              <div className="flex justify-between text-sm">
-                                <span className="text-gray-600">
-                                  Processed Orders:
-                                </span>
-                                <span>{record.processed_orders}</span>
-                              </div>
-                              <div className="flex justify-between text-sm">
-                                <span className="text-gray-600">
-                                  Processed Purchase Orders:
-                                </span>
-                                <span>{record.processed_purchase_orders}</span>
-                              </div>
-                              {record.error_message && (
-                                <div className="text-sm text-red-600 mt-2">
-                                  {record.error_message}
-            </div>
-          )}
-                              {record.additional_info &&
-                                formatJsonData(record.additional_info)}
-                            </div>
-                          </AccordionContent>
-                        </AccordionItem>
-                      </Accordion>
+                            </AccordionContent>
+                          </AccordionItem>
+                        </Accordion>
+                      </TableCell>
+                    </TableRow>
+                  ))
+                ) : (
+                  <TableRow>
+                    <TableCell className="text-center text-sm text-muted-foreground py-4">
+                      No calculation history available
                     </TableCell>
                   </TableRow>
-                ))}
+                )}
               </TableBody>
             </Table>
-        </CardContent>
+          </CardContent>
       </Card>
       </div>
     </div>

inventory/src/components/settings/TemplateManagement.tsx

@@ -0,0 +1,400 @@
+import { useState, useMemo } from "react";
+import { useQuery, useMutation, useQueryClient } from "@tanstack/react-query";
+import { Button } from "@/components/ui/button";
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table";
+import {
+  Dialog,
+  DialogContent,
+  DialogDescription,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+  DialogTrigger,
+} from "@/components/ui/dialog";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { ScrollArea } from "@/components/ui/scroll-area";
+import { toast } from "sonner";
+import config from "@/config";
+import {
+  useReactTable,
+  getCoreRowModel,
+  getSortedRowModel,
+  SortingState,
+  flexRender,
+  type ColumnDef,
+} from "@tanstack/react-table";
+import { ArrowUpDown, Pencil, Trash2, Loader2, Copy } from "lucide-react";
+import {
+  Command,
+  CommandEmpty,
+  CommandGroup,
+  CommandInput,
+  CommandItem,
+  CommandList,
+} from "@/components/ui/command";
+import {
+  Popover,
+  PopoverContent,
+  PopoverTrigger,
+} from "@/components/ui/popover";
+import { Check, ChevronsUpDown } from "lucide-react";
+import { cn } from "@/lib/utils";
+import { Textarea } from "@/components/ui/textarea";
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+} from "@/components/ui/alert-dialog";
+import { SearchProductTemplateDialog } from "@/components/templates/SearchProductTemplateDialog";
+import { TemplateForm } from "@/components/templates/TemplateForm";
+
+interface FieldOption {
+  label: string;
+  value: string;
+  type?: number;
+  level?: number;
+  hexColor?: string;
+}
+
+interface FieldOptions {
+  companies: FieldOption[];
+  artists: FieldOption[];
+  sizes: FieldOption[];
+  themes: FieldOption[];
+  categories: FieldOption[];
+  colors: FieldOption[];
+  suppliers: FieldOption[];
+  taxCategories: FieldOption[];
+  shippingRestrictions: FieldOption[];
+}
+
+interface Template {
+  id: number;
+  company: string;
+  product_type: string;
+  supplier?: string;
+  msrp?: number;
+  cost_each?: number;
+  qty_per_unit?: number;
+  case_qty?: number;
+  hts_code?: string;
+  description?: string;
+  weight?: number;
+  length?: number;
+  width?: number;
+  height?: number;
+  tax_cat?: string;
+  size_cat?: string;
+  categories?: string[];
+  ship_restrictions?: string[];
+  created_at: string;
+  updated_at: string;
+}
+
+interface TemplateFormData extends Omit<Template, 'id' | 'created_at' | 'updated_at'> {}
+
+export function TemplateManagement() {
+  const [isCreateOpen, setIsCreateOpen] = useState(false);
+  const [isSearchOpen, setIsSearchOpen] = useState(false);
+  const [isDeleteOpen, setIsDeleteOpen] = useState(false);
+  const [templateToDelete, setTemplateToDelete] = useState<Template | null>(null);
+  const [editingTemplate, setEditingTemplate] = useState<Template | null>(null);
+  const [sorting, setSorting] = useState<SortingState>([]);
+  const [searchQuery, setSearchQuery] = useState("");
+
+  const queryClient = useQueryClient();
+
+  const { data: templates, isLoading } = useQuery<Template[]>({
+    queryKey: ["templates"],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/templates`);
+      if (!response.ok) {
+        throw new Error("Failed to fetch templates");
+      }
+      return response.json();
+    },
+  });
+
+  const { data: fieldOptions } = useQuery<FieldOptions>({
+    queryKey: ["fieldOptions"],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/import/field-options`);
+      if (!response.ok) {
+        throw new Error("Failed to fetch field options");
+      }
+      return response.json();
+    },
+  });
+
+  const deleteMutation = useMutation({
+    mutationFn: async (id: number) => {
+      const response = await fetch(`${config.apiUrl}/templates/${id}`, {
+        method: "DELETE",
+      });
+      if (!response.ok) {
+        throw new Error("Failed to delete template");
+      }
+    },
+    onSuccess: () => {
+      queryClient.invalidateQueries({ queryKey: ["templates"] });
+      toast.success("Template deleted successfully");
+    },
+    onError: (error) => {
+      toast.error(error instanceof Error ? error.message : "Failed to delete template");
+    },
+  });
+
+  const handleEdit = (template: Template) => {
+    setEditingTemplate(template);
+  };
+
+  const handleCopy = (template: Template) => {
+    // Remove id and timestamps for copy operation
+    const { id, created_at, updated_at, ...templateData } = template;
+    // Set as new template with empty product type
+    setEditingTemplate({
+      ...templateData,
+      product_type: '',
+      id: 0 // Add a temporary ID to indicate it's a copy
+    } as Template);
+  };
+
+  const handleDeleteClick = (template: Template) => {
+    setTemplateToDelete(template);
+    setIsDeleteOpen(true);
+  };
+
+  const handleDeleteConfirm = () => {
+    if (templateToDelete) {
+      deleteMutation.mutate(templateToDelete.id);
+      setIsDeleteOpen(false);
+      setTemplateToDelete(null);
+    }
+  };
+
+  const handleTemplateSuccess = () => {
+    queryClient.invalidateQueries({ queryKey: ["templates"] });
+  };
+
+  const columns = useMemo<ColumnDef<Template>[]>(() => [
+    {
+      accessorKey: "company",
+      header: ({ column }) => (
+        <Button
+          variant="ghost"
+          onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}
+        >
+          Company
+          <ArrowUpDown className="ml-2 h-4 w-4" />
+        </Button>
+      ),
+      cell: ({ row }) => {
+        const companyId = row.getValue("company");
+        return fieldOptions?.companies.find(c => c.value === companyId)?.label || companyId;
+      },
+    },
+    {
+      accessorKey: "product_type",
+      header: ({ column }) => (
+        <Button
+          variant="ghost"
+          onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}
+        >
+          Product Type
+          <ArrowUpDown className="ml-2 h-4 w-4" />
+        </Button>
+      ),
+    },
+    {
+      accessorKey: "updated_at",
+      header: ({ column }) => (
+        <Button
+          variant="ghost"
+          onClick={() => column.toggleSorting(column.getIsSorted() === "asc")}
+        >
+          Last Updated
+          <ArrowUpDown className="ml-2 h-4 w-4" />
+        </Button>
+      ),
+      cell: ({ row }) => new Date(row.getValue("updated_at")).toLocaleDateString(),
+    },
+    {
+      id: "actions",
+      cell: ({ row }) => (
+        <div className="flex gap-2 justify-end pr-4">
+          <Button
+            variant="ghost"
+            onClick={() => handleEdit(row.original)}
+          >
+            <Pencil className="h-4 w-4" />
+            Edit
+          </Button>
+          <Button
+            variant="ghost"
+            onClick={() => handleCopy(row.original)}
+          >
+            <Copy className="h-4 w-4" />
+            Copy
+          </Button>
+          <Button
+            variant="ghost"
+            className="text-destructive hover:text-destructive"
+            onClick={() => handleDeleteClick(row.original)}
+          >
+            <Trash2 className="h-4 w-4" />
+            Delete
+          </Button>
+        </div>
+      ),
+    },
+  ], [fieldOptions]);
+
+  const filteredData = useMemo(() => {
+    if (!templates) return [];
+    return templates.filter((template) => {
+      const searchString = searchQuery.toLowerCase();
+      return (
+        template.company.toLowerCase().includes(searchString) ||
+        template.product_type.toLowerCase().includes(searchString) ||
+        (template.supplier?.toLowerCase().includes(searchString) ?? false)
+      );
+    });
+  }, [templates, searchQuery]);
+
+  const table = useReactTable({
+    data: filteredData,
+    columns,
+    state: {
+      sorting,
+    },
+    onSortingChange: setSorting,
+    getSortedRowModel: getSortedRowModel(),
+    getCoreRowModel: getCoreRowModel(),
+  });
+
+  return (
+    <div className="space-y-6">
+      <div className="flex items-center justify-between">
+        <h2 className="text-2xl font-bold">Import Templates</h2>
+        <div className="flex gap-2">
+          <Button onClick={() => setIsCreateOpen(true)}>
+            Create Blank Template
+          </Button>
+          <Button onClick={() => setIsSearchOpen(true)}>
+            Create from Product
+          </Button>
+        </div>
+      </div>
+
+      <div className="flex items-center gap-4">
+        <Input
+          placeholder="Search templates..."
+          value={searchQuery}
+          onChange={(e) => setSearchQuery(e.target.value)}
+          className="max-w-sm"
+        />
+      </div>
+
+      {isLoading ? (
+        <div>Loading templates...</div>
+      ) : (
+        <div className="border rounded-lg">
+          <Table>
+            <TableHeader className="bg-muted">
+              {table.getHeaderGroups().map((headerGroup) => (
+                <TableRow key={headerGroup.id}>
+                  {headerGroup.headers.map((header) => (
+                    <TableHead key={header.id}>
+                      {header.isPlaceholder
+                        ? null
+                        : flexRender(
+                            header.column.columnDef.header,
+                            header.getContext()
+                          )}
+                    </TableHead>
+                  ))}
+                </TableRow>
+              ))}
+            </TableHeader>
+            <TableBody>
+              {table.getRowModel().rows?.length ? (
+                table.getRowModel().rows.map((row) => (
+                  <TableRow key={row.id} className="hover:bg-gray-100">
+                    {row.getVisibleCells().map((cell) => (
+                      <TableCell key={cell.id} className="pl-6">
+                        {flexRender(cell.column.columnDef.cell, cell.getContext())}
+                      </TableCell>
+                    ))}
+                  </TableRow>
+                ))
+              ) : (
+                <TableRow>
+                  <TableCell colSpan={columns.length} className="text-center">
+                    No templates found
+                  </TableCell>
+                </TableRow>
+              )}
+            </TableBody>
+          </Table>
+        </div>
+      )}
+
+      {/* Template Form for Create/Edit/Copy */}
+      <TemplateForm
+        isOpen={isCreateOpen || (editingTemplate !== null)}
+        onClose={() => {
+          setIsCreateOpen(false);
+          setEditingTemplate(null);
+        }}
+        onSuccess={handleTemplateSuccess}
+        initialData={editingTemplate || undefined}
+        mode={editingTemplate ? (editingTemplate.id ? 'edit' : 'copy') : 'create'}
+        templateId={editingTemplate?.id}
+        fieldOptions={fieldOptions}
+      />
+
+      {/* Product Search Dialog */}
+      <SearchProductTemplateDialog
+        isOpen={isSearchOpen}
+        onClose={() => setIsSearchOpen(false)}
+        onTemplateCreated={handleTemplateSuccess}
+      />
+
+      {/* Delete Confirmation Dialog */}
+      <AlertDialog open={isDeleteOpen} onOpenChange={setIsDeleteOpen}>
+        <AlertDialogContent>
+          <AlertDialogHeader>
+            <AlertDialogTitle>Delete Template</AlertDialogTitle>
+            <AlertDialogDescription>
+              Are you sure you want to delete this template? This action cannot be undone.
+            </AlertDialogDescription>
+          </AlertDialogHeader>
+          <AlertDialogFooter>
+            <AlertDialogCancel onClick={() => {
+              setIsDeleteOpen(false);
+              setTemplateToDelete(null);
+            }}>
+              Cancel
+            </AlertDialogCancel>
+            <AlertDialogAction onClick={handleDeleteConfirm}>
+              Delete
+            </AlertDialogAction>
+          </AlertDialogFooter>
+        </AlertDialogContent>
+      </AlertDialog>
+    </div>
+  );
+}

inventory/src/components/templates/SearchProductTemplateDialog.tsx

@@ -0,0 +1,968 @@
+import React, { useState, useEffect, useCallback, useMemo, useRef } from 'react';
+import axios from 'axios';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, DialogDescription } from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Textarea } from '@/components/ui/textarea';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Loader2, Search, ChevronsUpDown, Check, X, ChevronUp, ChevronDown } from 'lucide-react';
+import { toast } from 'sonner';
+import { Table, TableBody, TableCell, TableHead, TableHeader, TableRow } from '@/components/ui/table';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
+import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from '@/components/ui/command';
+import { cn } from '@/lib/utils';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import {
+  Pagination,
+  PaginationContent,
+  PaginationEllipsis,
+  PaginationItem,
+  PaginationLink,
+  PaginationNext,
+  PaginationPrevious,
+} from "@/components/ui/pagination";
+import { Badge } from "@/components/ui/badge";
+import { TemplateForm } from '@/components/templates/TemplateForm';
+
+interface ProductSearchDialogProps {
+  isOpen: boolean;
+  onClose: () => void;
+  onTemplateCreated: () => void;
+}
+
+interface Product {
+  pid: number;
+  title: string;
+  description: string;
+  sku: string;
+  barcode: string;
+  harmonized_tariff_code: string;
+  price: number;
+  regular_price: number;
+  cost_price: number;
+  vendor: string;
+  vendor_reference: string;
+  notions_reference: string;
+  brand: string;
+  brand_id: string;
+  line: string;
+  line_id: string;
+  subline: string;
+  subline_id: string;
+  artist: string;
+  artist_id: string;
+  moq: number;
+  weight: number;
+  length: number;
+  width: number;
+  height: number;
+  country_of_origin: string;
+  total_sold: number;
+  first_received: string | null;
+  date_last_sold: string | null;
+  supplier?: string;
+  categories?: string[];
+  tax_code?: string;
+  size_cat?: string;
+  shipping_restrictions?: string;
+  case_qty?: number;
+}
+
+interface FieldOption {
+  label: string;
+  value: string;
+  type?: number;
+  level?: number;
+  hexColor?: string;
+}
+
+interface FieldOptions {
+  companies: FieldOption[];
+  artists: FieldOption[];
+  sizes: FieldOption[];
+  themes: FieldOption[];
+  categories: FieldOption[];
+  colors: FieldOption[];
+  suppliers: FieldOption[];
+  taxCategories: FieldOption[];
+  shippingRestrictions: FieldOption[];
+}
+
+interface TemplateFormData {
+  company: string;
+  product_type: string;
+  supplier?: string;
+  msrp?: number;
+  cost_each?: number;
+  qty_per_unit?: number;
+  case_qty?: number;
+  hts_code?: string;
+  description?: string;
+  weight?: number;
+  length?: number;
+  width?: number;
+  height?: number;
+  tax_cat?: string;
+  size_cat?: string;
+  categories?: string[];
+  ship_restrictions?: string;
+}
+
+// Add sorting types
+type SortDirection = 'asc' | 'desc' | null;
+type SortField = 'title' | 'brand' | 'line' | 'price' | 'total_sold' | 'first_received' | 'date_last_sold' | null;
+
+// Date filter options
+const DATE_FILTER_OPTIONS = [
+  { label: "Any Time", value: "none" },
+  { label: "Last week", value: "1week" },
+  { label: "Last month", value: "1month" },
+  { label: "Last 2 months", value: "2months" },
+  { label: "Last 3 months", value: "3months" },
+  { label: "Last 6 months", value: "6months" },
+  { label: "Last year", value: "1year" }
+];
+
+// Create a memoized search component to prevent unnecessary re-renders
+const SearchInput = React.memo(({ 
+  searchTerm, 
+  setSearchTerm, 
+  handleSearch, 
+  isLoading,
+  onClear
+}: { 
+  searchTerm: string;
+  setSearchTerm: (term: string) => void;
+  handleSearch: () => void;
+  isLoading: boolean;
+  onClear: () => void;
+}) => {
+  // Use local state to buffer updates
+  const [localTerm, setLocalTerm] = useState(searchTerm);
+  
+  // Keep local state in sync with props
+  useEffect(() => {
+    setLocalTerm(searchTerm);
+  }, [searchTerm]);
+  
+  // Only update parent state when submission happens
+  const handleSubmit = (e: React.FormEvent) => { 
+    e.preventDefault(); 
+    if (localTerm !== searchTerm) {
+      setSearchTerm(localTerm);
+    }
+    handleSearch(); 
+  };
+  
+  // Handle Enter key press
+  const handleKeyDown = (e: React.KeyboardEvent<HTMLInputElement>) => {
+    if (e.key === 'Enter') {
+      if (localTerm !== searchTerm) {
+        setSearchTerm(localTerm);
+      }
+      handleSearch();
+    }
+  };
+  
+  return (
+    <form onSubmit={handleSubmit} className="flex items-center space-x-2">
+      <div className="relative flex-1">
+        <Input
+          placeholder="Search..."
+          value={localTerm}
+          onChange={(e) => setLocalTerm(e.target.value)}
+          onKeyDown={handleKeyDown}
+          className="pr-8"
+        />
+        {localTerm && (
+          <Button
+            type="button"
+            variant="ghost"
+            size="icon"
+            className="absolute right-0 top-0 h-full w-8 p-0"
+            onClick={() => {
+              setLocalTerm('');
+              onClear();
+            }}
+          >
+            <X className="h-4 w-4" />
+          </Button>
+        )}
+      </div>
+      <Button type="submit" disabled={isLoading}>
+        {isLoading ? <Loader2 className="h-4 w-4 animate-spin" /> : <Search className="h-4 w-4" />}
+      </Button>
+    </form>
+  );
+});
+
+// Create a memoized filter component
+const FilterSelects = React.memo(({ 
+  selectedCompany,
+  setSelectedCompany,
+  selectedDateFilter,
+  setSelectedDateFilter,
+  companies,
+  onFilterChange
+}: {
+  selectedCompany: string;
+  setSelectedCompany: (value: string) => void;
+  selectedDateFilter: string;
+  setSelectedDateFilter: (value: string) => void;
+  companies: FieldOption[];
+  onFilterChange: (type: string, value: string) => void;
+}) => {
+  // Forward these to the parent component's updateSearchParams function
+  const handleCompanyChange = (value: string) => {
+    setSelectedCompany(value);
+  };
+
+  const handleDateFilterChange = (value: string) => {
+    setSelectedDateFilter(value);
+  };
+
+  return (
+    <div className="grid grid-cols-2 gap-4">
+      <div>
+        <Label htmlFor="company-filter" className="text-sm">Filter by Company</Label>
+        <Select 
+          value={selectedCompany} 
+          onValueChange={handleCompanyChange}
+        >
+          <SelectTrigger id="company-filter">
+            <SelectValue placeholder="Any Company" />
+          </SelectTrigger>
+          <SelectContent>
+            <SelectItem value="all">Any Company</SelectItem>
+            {companies.map((company) => (
+              <SelectItem key={company.value} value={company.value}>
+                {company.label}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+      
+      <div>
+        <Label htmlFor="date-filter" className="text-sm">Filter by Date</Label>
+        <Select 
+          value={selectedDateFilter} 
+          onValueChange={handleDateFilterChange}
+        >
+          <SelectTrigger id="date-filter">
+            <SelectValue placeholder="Any Time" />
+          </SelectTrigger>
+          <SelectContent>
+            {DATE_FILTER_OPTIONS.map((filter) => (
+              <SelectItem key={filter.value} value={filter.value}>
+                {filter.label}
+              </SelectItem>
+            ))}
+          </SelectContent>
+        </Select>
+      </div>
+    </div>
+  );
+});
+
+// Create a memoized results table component
+const ResultsTable = React.memo(({ 
+  results,
+  selectedCompany,
+  onSelect
+}: {
+  results: any[];
+  selectedCompany: string;
+  onSelect: (product: any) => void;
+}) => (
+  <Table>
+    <TableHeader>
+      <TableRow>
+        <TableHead>Name</TableHead>
+        {selectedCompany === 'all' && <TableHead>Company</TableHead>}
+        <TableHead>Line</TableHead>
+        <TableHead>Price</TableHead>
+        <TableHead>Total Sold</TableHead>
+        <TableHead>Date In</TableHead>
+        <TableHead>Last Sold</TableHead>
+      </TableRow>
+    </TableHeader>
+    <TableBody>
+      {results.map((product) => (
+        <TableRow
+          key={product.pid}
+          className="cursor-pointer hover:bg-muted/50"
+          onClick={() => onSelect(product)}
+        >
+          <TableCell>{product.title}</TableCell>
+          {selectedCompany === 'all' && <TableCell>{product.brand || '-'}</TableCell>}
+          <TableCell>{product.line || '-'}</TableCell>
+          <TableCell>
+            {product.price != null ? `$${Number(product.price).toFixed(2)}` : '-'}
+          </TableCell>
+          <TableCell>{product.total_sold || 0}</TableCell>
+          <TableCell>
+            {product.first_received
+              ? new Date(product.first_received).toLocaleDateString()
+              : '-'}
+          </TableCell>
+          <TableCell>
+            {product.date_last_sold
+              ? new Date(product.date_last_sold).toLocaleDateString()
+              : '-'}
+          </TableCell>
+        </TableRow>
+      ))}
+    </TableBody>
+  </Table>
+));
+
+export function SearchProductTemplateDialog({ isOpen, onClose, onTemplateCreated }: ProductSearchDialogProps) {
+  // Basic component state
+  const [searchResults, setSearchResults] = useState<Product[]>([]);
+  const [isLoading, setIsLoading] = useState(false);
+  const [step, setStep] = useState<'search' | 'form'>('search');
+  const [selectedProduct, setSelectedProduct] = useState<Product | null>(null);
+  const [fieldOptions, setFieldOptions] = useState<FieldOptions | null>(null);
+  const [currentPage, setCurrentPage] = useState(1);
+  const productsPerPage = 500;
+  const [hasSearched, setHasSearched] = useState(false);
+  
+  // Consolidated search parameters state
+  const [searchParams, setSearchParams] = useState({
+    searchTerm: '',
+    company: 'all',
+    dateFilter: 'none'
+  });
+  
+  // Sorting states
+  const [sortField, setSortField] = useState<SortField>(null);
+  const [sortDirection, setSortDirection] = useState<SortDirection>(null);
+
+  // Debug log for selectedProduct values
+  React.useEffect(() => {
+    if (selectedProduct) {
+      console.log('Selected Product Details:', {
+        tax_code: selectedProduct.tax_code,
+        size_cat: selectedProduct.size_cat,
+        shipping_restrictions: selectedProduct.shipping_restrictions
+      });
+    }
+  }, [selectedProduct]);
+
+  // Simple helper function to check if any filters are active
+  const hasActiveFilters = () => {
+    return searchParams.company !== 'all' || searchParams.dateFilter !== 'none';
+  };
+
+  // Central function to update search parameters
+  const updateSearchParams = (newParams: Partial<typeof searchParams>, shouldSearch = true) => {
+    // Create updated parameters object
+    const updatedParams = { ...searchParams, ...newParams };
+    
+    // First update the state synchronously
+    setSearchParams(updatedParams);
+    
+    // If we should trigger a search, do it in the next microtask
+    // to ensure state updates have been processed
+    if (shouldSearch) {
+      // Use a local copy of the params to ensure consistency
+      queueMicrotask(() => {
+        performSearch(updatedParams);
+      });
+    }
+  };
+
+  // Core search function
+  const performSearch = async (params: typeof searchParams = searchParams) => {
+    setIsLoading(true);
+    
+    // Use the provided params or the current state
+    const searchParamsToUse = params || searchParams;
+    
+    const hasSearchTerm = searchParamsToUse.searchTerm.trim().length > 0;
+    const hasFilters = searchParamsToUse.company !== 'all' || searchParamsToUse.dateFilter !== 'none';
+    
+    // Update search state
+    setHasSearched(hasSearchTerm || hasFilters);
+    
+    // If no search parameters, reset results
+    if (!hasSearchTerm && !hasFilters) {
+      setSearchResults([]);
+      setHasSearched(false);
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      const apiParams: Record<string, any> = {};
+      
+      // Add search term if it exists
+      if (hasSearchTerm) {
+        apiParams.q = searchParamsToUse.searchTerm.trim();
+      }
+      
+      // Add filters if selected
+      if (searchParamsToUse.company !== 'all') {
+        apiParams.company = searchParamsToUse.company;
+      }
+      
+      if (searchParamsToUse.dateFilter !== 'none') {
+        apiParams.dateRange = searchParamsToUse.dateFilter;
+      }
+
+      // If we only have filters (no search term), use wildcard search
+      if (!hasSearchTerm && hasFilters) {
+        apiParams.q = '*';
+      }
+
+      const response = await axios.get('/api/import/search-products', { params: apiParams });
+
+      setSearchResults(response.data.map((product: Product) => ({
+        ...product,
+        pid: typeof product.pid === 'string' ? parseInt(product.pid, 10) : product.pid,
+        price: typeof product.price === 'string' ? parseFloat(product.price) : product.price,
+      })));
+    } catch (error) {
+      console.error('Error searching products:', error);
+      toast.error('Failed to search products', {
+        description: 'Could not retrieve search results from the server'
+      });
+      setSearchResults([]);
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  // Handler functions
+  const handleSearch = () => {
+    performSearch();
+  };
+
+  const clearSearch = () => {
+    updateSearchParams({ searchTerm: '' });
+  };
+
+  const clearFilters = () => {
+    // One call to updateSearchParams with all filter changes
+    // This ensures all filters are cleared in a single atomic update
+    updateSearchParams({
+      company: 'all',
+      dateFilter: 'none'
+    });
+  };
+
+  // Reset all search state when dialog is closed
+  useEffect(() => {
+    if (!isOpen) {
+      setSearchParams({
+        searchTerm: '',
+        company: 'all',
+        dateFilter: 'none'
+      });
+      setSearchResults([]);
+      setSortField(null);
+      setSortDirection(null);
+      setCurrentPage(1);
+      setStep('search');
+      setHasSearched(false);
+      setSelectedProduct(null);
+    } else {
+      // Fetch field options when dialog opens
+      fetchFieldOptions();
+    }
+  }, [isOpen]);
+
+  // Fetch field options when component mounts
+  useEffect(() => {
+    if (isOpen) {
+      fetchFieldOptions();
+    }
+  }, [isOpen]);
+
+  const fetchFieldOptions = async () => {
+    try {
+      const response = await axios.get('/api/import/field-options');
+      setFieldOptions(response.data);
+    } catch (error) {
+      console.error('Error fetching field options:', error);
+      toast.error('Failed to fetch field options', {
+        description: 'Could not retrieve field options from the server'
+      });
+    }
+  };
+
+  const handleProductSelect = async (product: Product) => {
+    console.log('Selected product from list:', {
+      pid: product.pid,
+      tax_code: product.tax_code,
+      tax_code_type: typeof product.tax_code,
+      tax_code_value: `Value: '${product.tax_code}'`,
+      size_cat: product.size_cat,
+      shipping_restrictions: product.shipping_restrictions,
+      case_qty: product.case_qty
+    });
+    
+    setSelectedProduct(product);
+    
+    // Try to find a matching company ID
+    let companyId = '';
+    if (product.brand_id && fieldOptions?.companies) {
+      // Attempt to match by brand ID
+      const companyMatch = fieldOptions.companies.find(c => c.value === product.brand_id);
+      if (companyMatch) {
+        companyId = companyMatch.value;
+      }
+    }
+    
+    // Fetch product categories if pid is available
+    if (product.pid) {
+      try {
+        const response = await axios.get(`/api/import/product-categories/${product.pid}`);
+        const productCategories = response.data;
+        
+        // Update the selected product with the categories
+        setSelectedProduct(prev => ({
+          ...prev!,
+          categories: productCategories.map((cat: any) => cat.value)
+        }));
+      } catch (error) {
+        console.error('Error fetching product categories:', error);
+        toast.error('Failed to fetch product categories', {
+          description: 'Could not retrieve categories for this product'
+        });
+      }
+    }
+    
+    setStep('form');
+  };
+
+  // Get current products for pagination
+  const totalPages = Math.ceil(searchResults.length / productsPerPage);
+
+  // Change page
+  const paginate = (pageNumber: number) => setCurrentPage(pageNumber);
+
+  // Generate page numbers for pagination
+  const getPageNumbers = () => {
+    const pageNumbers = [];
+    const maxPagesToShow = 5;
+    
+    if (totalPages <= maxPagesToShow) {
+      // If we have fewer pages than the max to show, display all pages
+      for (let i = 1; i <= totalPages; i++) {
+        pageNumbers.push(i);
+      }
+    } else {
+      // Always include first page
+      pageNumbers.push(1);
+      
+      // Calculate start and end of middle pages
+      let startPage = Math.max(2, currentPage - 1);
+      let endPage = Math.min(totalPages - 1, currentPage + 1);
+      
+      // Adjust if we're near the beginning
+      if (currentPage <= 3) {
+        endPage = Math.min(totalPages - 1, 4);
+      }
+      
+      // Adjust if we're near the end
+      if (currentPage >= totalPages - 2) {
+        startPage = Math.max(2, totalPages - 3);
+      }
+      
+      // Add ellipsis after first page if needed
+      if (startPage > 2) {
+        pageNumbers.push('ellipsis-start');
+      }
+      
+      // Add middle pages
+      for (let i = startPage; i <= endPage; i++) {
+        pageNumbers.push(i);
+      }
+      
+      // Add ellipsis before last page if needed
+      if (endPage < totalPages - 1) {
+        pageNumbers.push('ellipsis-end');
+      }
+      
+      // Always include last page
+      pageNumbers.push(totalPages);
+    }
+    
+    return pageNumbers;
+  };
+
+  // Sort function
+  const toggleSort = (field: SortField) => {
+    if (sortField === field) {
+      // Toggle direction if already sorting by this field
+      if (sortDirection === 'asc') {
+        setSortDirection('desc');
+      } else if (sortDirection === 'desc') {
+        setSortField(null);
+        setSortDirection(null);
+      }
+    } else {
+      // Set new sort field and direction
+      setSortField(field);
+      setSortDirection('asc');
+    }
+    
+    // Reset to page 1 when sorting changes
+    setCurrentPage(1);
+  };
+
+  // Apply sorting to results
+  const getSortedResults = (results: Product[]) => {
+    if (!sortField || !sortDirection) return results;
+    
+    return [...results].sort((a, b) => {
+      let valueA: any;
+      let valueB: any;
+      
+      // Extract the correct field values
+      switch (sortField) {
+        case 'title':
+          valueA = a.title?.toLowerCase() || '';
+          valueB = b.title?.toLowerCase() || '';
+          break;
+        case 'brand':
+          valueA = a.brand?.toLowerCase() || '';
+          valueB = b.brand?.toLowerCase() || '';
+          break;
+        case 'line':
+          valueA = a.line?.toLowerCase() || '';
+          valueB = b.line?.toLowerCase() || '';
+          break;
+        case 'price':
+          valueA = typeof a.price === 'number' ? a.price : parseFloat(String(a.price) || '0');
+          valueB = typeof b.price === 'number' ? b.price : parseFloat(String(b.price) || '0');
+          break;
+        case 'total_sold':
+          valueA = typeof a.total_sold === 'number' ? a.total_sold : parseInt(String(a.total_sold) || '0', 10);
+          valueB = typeof b.total_sold === 'number' ? b.total_sold : parseInt(String(b.total_sold) || '0', 10);
+          break;
+        case 'first_received':
+          valueA = a.first_received ? new Date(a.first_received).getTime() : 0;
+          valueB = b.first_received ? new Date(b.first_received).getTime() : 0;
+          break;
+        case 'date_last_sold':
+          valueA = a.date_last_sold ? new Date(a.date_last_sold).getTime() : 0;
+          valueB = b.date_last_sold ? new Date(b.date_last_sold).getTime() : 0;
+          break;
+        default:
+          return 0;
+      }
+      
+      // Compare the values
+      if (valueA < valueB) {
+        return sortDirection === 'asc' ? -1 : 1;
+      }
+      if (valueA > valueB) {
+        return sortDirection === 'asc' ? 1 : -1;
+      }
+      return 0;
+    });
+  };
+
+  // Update getFilteredResults to remove redundant company filtering
+  const getFilteredResults = () => {
+    if (!searchResults) return [];
+    return searchResults;
+  };
+
+  const filteredResults = getFilteredResults();
+  const sortedResults = getSortedResults(filteredResults);
+  
+  // Get current products for pagination
+  const indexOfLastProductFiltered = currentPage * productsPerPage;
+  const indexOfFirstProductFiltered = indexOfLastProductFiltered - productsPerPage;
+  const currentProductsFiltered = sortedResults.slice(indexOfFirstProductFiltered, indexOfLastProductFiltered);
+  const totalPagesFiltered = Math.ceil(sortedResults.length / productsPerPage);
+
+  // Get sort icon
+  const getSortIcon = (field: SortField) => {
+    if (sortField !== field) {
+      return <ChevronsUpDown className="ml-1 h-3 w-3 opacity-50" />;
+    }
+    
+    return sortDirection === 'asc' 
+      ? <ChevronUp className="ml-1 h-3 w-3" />
+      : <ChevronDown className="ml-1 h-3 w-3" />;
+  };
+
+  // Sortable table header component
+  const SortableTableHead = ({ field, children }: { field: SortField, children: React.ReactNode }) => (
+    <TableHead 
+      className="cursor-pointer hover:bg-muted/50 transition-colors"
+      onClick={() => toggleSort(field)}
+    >
+      <div className="flex items-center">
+        {children}
+        {getSortIcon(field)}
+      </div>
+    </TableHead>
+  );
+
+  return (
+    <Dialog open={isOpen} onOpenChange={(open) => !open && onClose()}>
+      <DialogContent className={`max-h-[95vh] flex flex-col p-6 ${
+        step === 'search' 
+          ? searchResults.length > 0 
+            ? 'max-w-5xl' 
+            : 'max-w-2xl'
+          : 'max-w-2xl'
+      }`}>
+        {step === 'search' ? (
+          <>
+            <DialogHeader className="px-0">
+              <DialogTitle>Search Products</DialogTitle>
+              <DialogDescription>
+                Search for a product you want to use as a template.
+              </DialogDescription>
+            </DialogHeader>
+            
+            <div className="flex-1 overflow-hidden py-4 px-1">
+              <div className="flex flex-col gap-4">
+                <SearchInput
+                  searchTerm={searchParams.searchTerm}
+                  setSearchTerm={(term) => updateSearchParams({ searchTerm: term }, false)}
+                  handleSearch={handleSearch}
+                  isLoading={isLoading}
+                  onClear={clearSearch}
+                />
+                
+                <FilterSelects
+                  selectedCompany={searchParams.company}
+                  setSelectedCompany={(value) => updateSearchParams({ company: value })}
+                  selectedDateFilter={searchParams.dateFilter}
+                  setSelectedDateFilter={(value) => updateSearchParams({ dateFilter: value })}
+                  companies={fieldOptions?.companies || []}
+                  onFilterChange={() => {}}
+                />
+                
+                {fieldOptions && hasActiveFilters() && (
+                  <div className="flex gap-2">
+                    <div className="text-sm text-muted-foreground">Active filters:</div>
+                    <div className="flex flex-wrap gap-2">
+                      {searchParams.company !== 'all' && (
+                        <Badge variant="secondary" className="flex items-center gap-1">
+                          Company: {fieldOptions?.companies?.find(c => c.value === searchParams.company)?.label || 'Unknown'}
+                          <Button 
+                            variant="ghost" 
+                            size="icon" 
+                            className="h-4 w-4 p-0 ml-1" 
+                            onClick={() => {
+                              updateSearchParams({ company: 'all' });
+                            }}
+                          >
+                            <X className="h-3 w-3" />
+                          </Button>
+                        </Badge>
+                      )}
+                      {searchParams.dateFilter !== 'none' && (
+                        <Badge variant="secondary" className="flex items-center gap-1">
+                          Date: {(() => {
+                            const selectedOption = DATE_FILTER_OPTIONS.find(o => o.value === searchParams.dateFilter);
+                            return selectedOption ? selectedOption.label : 'Custom range';
+                          })()}
+                          <Button 
+                            variant="ghost" 
+                            size="icon" 
+                            className="h-4 w-4 p-0 ml-1" 
+                            onClick={() => {
+                              updateSearchParams({ dateFilter: 'none' });
+                            }}
+                          >
+                            <X className="h-3 w-3" />
+                          </Button>
+                        </Badge>
+                      )}
+                      <Button 
+                        variant="ghost" 
+                        size="sm" 
+                        className="h-6 text-xs" 
+                        onClick={clearFilters}
+                      >
+                        Clear All
+                      </Button>
+                    </div>
+                  </div>
+                )}
+              </div>
+              
+              <div className="mt-4">
+                <ScrollArea className="flex-1 -mr-6 pr-6 overflow-y-auto max-h-[60vh]">
+                  {isLoading ? (
+                    <div className="text-center py-4 text-muted-foreground flex items-center justify-center gap-2">
+                      <Loader2 className="h-4 w-4 animate-spin" />
+                      <span>Searching...</span>
+                    </div>
+                  ) : !hasSearched ? (
+                    <div className="text-center py-4 text-muted-foreground">
+                      Use the search field or filters to find products
+                    </div>
+                  ) : searchResults.length === 0 ? (
+                    <div className="text-center py-4 text-muted-foreground">
+                      No products found matching your criteria
+                    </div>
+                  ) : (
+                    <>
+                      <div className="text-sm text-muted-foreground mb-2">
+                        {sortedResults.length} products found
+                      </div>
+                      <div className="relative">
+                        <Table>
+                          <TableHeader className="sticky top-0 bg-background z-10 border-b">
+                            <TableRow>
+                              <SortableTableHead field="title">Name</SortableTableHead>
+                              {searchParams.company === 'all' && (
+                                <SortableTableHead field="brand">Company</SortableTableHead>
+                              )}
+                              <SortableTableHead field="line">Line</SortableTableHead>
+                              <SortableTableHead field="price">Price</SortableTableHead>
+                              <SortableTableHead field="total_sold">Total Sold</SortableTableHead>
+                              <SortableTableHead field="first_received">Date In</SortableTableHead>
+                              <SortableTableHead field="date_last_sold">Last Sold</SortableTableHead>
+                            </TableRow>
+                          </TableHeader>
+                          <TableBody>
+                            {currentProductsFiltered.map((product) => (
+                              <TableRow 
+                                key={product.pid}
+                                className="cursor-pointer"
+                                onClick={() => handleProductSelect(product)}
+                              >
+                                <TableCell className="font-medium">{product.title}</TableCell>
+                                {searchParams.company === 'all' && (
+                                  <TableCell>{product.brand || '-'}</TableCell>
+                                )}
+                                <TableCell>{product.line || '-'}</TableCell>
+                                <TableCell>
+                                  {product.price !== null && product.price !== undefined
+                                    ? `$${typeof product.price === 'number' 
+                                        ? product.price.toFixed(2) 
+                                        : parseFloat(String(product.price)).toFixed(2)}`
+                                    : '-'}
+                                </TableCell>
+                                <TableCell>
+                                  {product.total_sold !== null && product.total_sold !== undefined
+                                    ? typeof product.total_sold === 'number'
+                                      ? product.total_sold
+                                      : parseInt(String(product.total_sold), 10)
+                                    : 0}
+                                </TableCell>
+                                <TableCell>
+                                  {product.first_received 
+                                    ? (() => {
+                                        try {
+                                          return new Date(product.first_received).toLocaleDateString();
+                                        } catch (e) {
+                                          console.error('Error formatting first_received date:', e);
+                                          return '-';
+                                        }
+                                      })()
+                                    : '-'}
+                                </TableCell>
+                                <TableCell>
+                                  {product.date_last_sold 
+                                    ? (() => {
+                                        try {
+                                          return new Date(product.date_last_sold).toLocaleDateString();
+                                        } catch (e) {
+                                          console.error('Error formatting date_last_sold date:', e);
+                                          return '-';
+                                        }
+                                      })()
+                                    : '-'}
+                                </TableCell>
+                              </TableRow>
+                            ))}
+                          </TableBody>
+                        </Table>
+                      </div>
+                      
+                      {totalPagesFiltered > 1 && (
+                        <div className="mt-4">
+                          <Pagination>
+                            <PaginationContent>
+                              <PaginationItem>
+                                <PaginationPrevious 
+                                  onClick={() => currentPage > 1 && paginate(currentPage - 1)}
+                                  className={currentPage === 1 ? "pointer-events-none opacity-50" : "cursor-pointer"}
+                                />
+                              </PaginationItem>
+                              
+                              {getPageNumbers().map((page, index) => (
+                                <PaginationItem key={index}>
+                                  {page === 'ellipsis-start' || page === 'ellipsis-end' ? (
+                                    <PaginationEllipsis />
+                                  ) : (
+                                    <PaginationLink
+                                      isActive={page === currentPage}
+                                      onClick={() => typeof page === 'number' && paginate(page)}
+                                      className={typeof page === 'number' ? "cursor-pointer" : ""}
+                                    >
+                                      {page}
+                                    </PaginationLink>
+                                  )}
+                                </PaginationItem>
+                              ))}
+                              
+                              <PaginationItem>
+                                <PaginationNext 
+                                  onClick={() => currentPage < totalPagesFiltered && paginate(currentPage + 1)}
+                                  className={currentPage === totalPagesFiltered ? "pointer-events-none opacity-50" : "cursor-pointer"}
+                                />
+                              </PaginationItem>
+                            </PaginationContent>
+                          </Pagination>
+                        </div>
+                      )}
+                    </>
+                  )}
+                </ScrollArea>
+              </div>
+            </div>
+            
+            <DialogFooter className="px-0 mt-6">
+              <Button variant="outline" onClick={onClose}>Cancel</Button>
+            </DialogFooter>
+          </>
+        ) : (
+          <TemplateForm
+            isOpen={true}
+            onClose={() => setStep('search')}
+            onSuccess={onTemplateCreated}
+            initialData={selectedProduct ? (() => {
+              console.log('Creating TemplateForm initialData with tax_code:', selectedProduct.tax_code);
+              return {
+                company: selectedProduct.brand_id,
+                product_type: '',
+                supplier: selectedProduct.supplier,
+                msrp: selectedProduct.regular_price ? Number(Number(selectedProduct.regular_price).toFixed(2)) : undefined,
+                cost_each: selectedProduct.cost_price ? Number(Number(selectedProduct.cost_price).toFixed(2)) : undefined,
+                qty_per_unit: selectedProduct.moq ? Number(selectedProduct.moq) : undefined,
+                case_qty: selectedProduct.case_qty ? Number(selectedProduct.case_qty) : undefined,
+                hts_code: selectedProduct.harmonized_tariff_code || undefined,
+                description: selectedProduct.description || undefined,
+                weight: selectedProduct.weight ? Number(Number(selectedProduct.weight).toFixed(2)) : undefined,
+                length: selectedProduct.length ? Number(Number(selectedProduct.length).toFixed(2)) : undefined,
+                width: selectedProduct.width ? Number(Number(selectedProduct.width).toFixed(2)) : undefined,
+                height: selectedProduct.height ? Number(Number(selectedProduct.height).toFixed(2)) : undefined,
+                categories: selectedProduct.categories || [],
+                tax_cat: selectedProduct.tax_code ? String(selectedProduct.tax_code) : undefined,
+                size_cat: selectedProduct.size_cat ? String(selectedProduct.size_cat) : undefined,
+                ship_restrictions: selectedProduct.shipping_restrictions ? String(selectedProduct.shipping_restrictions) : undefined
+              };
+            })() : undefined}
+            mode="create"
+            fieldOptions={fieldOptions}
+          />
+        )}
+      </DialogContent>
+    </Dialog>
+  );
+} 

inventory/src/components/templates/TemplateForm.tsx

@@ -0,0 +1,719 @@
+import React from 'react';
+import { Dialog, DialogContent, DialogHeader, DialogTitle, DialogFooter, DialogDescription } from '@/components/ui/dialog';
+import { Button } from '@/components/ui/button';
+import { Input } from '@/components/ui/input';
+import { Label } from '@/components/ui/label';
+import { Textarea } from '@/components/ui/textarea';
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from '@/components/ui/select';
+import { Loader2, ChevronsUpDown, Check } from 'lucide-react';
+import { toast } from 'sonner';
+import { Popover, PopoverContent, PopoverTrigger } from '@/components/ui/popover';
+import { Command, CommandEmpty, CommandGroup, CommandInput, CommandItem, CommandList } from '@/components/ui/command';
+import { cn } from '@/lib/utils';
+import { ScrollArea } from '@/components/ui/scroll-area';
+import axios from 'axios';
+
+interface FieldOption {
+  label: string;
+  value: string;
+  type?: number;
+  level?: number;
+  hexColor?: string;
+}
+
+interface FieldOptions {
+  companies: FieldOption[];
+  artists: FieldOption[];
+  sizes: FieldOption[];
+  themes: FieldOption[];
+  categories: FieldOption[];
+  colors: FieldOption[];
+  suppliers: FieldOption[];
+  taxCategories: FieldOption[];
+  shippingRestrictions: FieldOption[];
+}
+
+interface TemplateFormData {
+  company: string;
+  product_type: string;
+  supplier?: string;
+  msrp?: number;
+  cost_each?: number;
+  qty_per_unit?: number;
+  case_qty?: number;
+  hts_code?: string;
+  description?: string;
+  weight?: number;
+  length?: number;
+  width?: number;
+  height?: number;
+  tax_cat?: string;
+  size_cat?: string;
+  categories?: string[];
+  ship_restrictions?: string;
+}
+
+interface TemplateFormProps {
+  isOpen: boolean;
+  onClose: () => void;
+  onSuccess: () => void;
+  initialData?: TemplateFormData;
+  mode: 'create' | 'edit' | 'copy';
+  templateId?: number;
+  fieldOptions: FieldOptions | null;
+}
+
+export function TemplateForm({ 
+  isOpen, 
+  onClose, 
+  onSuccess, 
+  initialData, 
+  mode,
+  templateId,
+  fieldOptions
+}: TemplateFormProps) {
+  const defaultFormData = {
+    company: "",
+    product_type: "",
+    supplier: undefined,
+    msrp: undefined,
+    cost_each: undefined,
+    qty_per_unit: undefined,
+    case_qty: undefined,
+    hts_code: undefined,
+    description: undefined,
+    weight: undefined,
+    length: undefined,
+    width: undefined,
+    height: undefined,
+    tax_cat: "0",
+    size_cat: undefined,
+    categories: [],
+    ship_restrictions: "0"
+  };
+
+  const [formData, setFormData] = React.useState<TemplateFormData>(defaultFormData);
+  const [isSubmitting, setIsSubmitting] = React.useState(false);
+
+  // Reset form data when dialog opens/closes or mode changes
+  React.useEffect(() => {
+    if (isOpen) {
+      if (initialData) {
+        console.log('Setting initial form data:', initialData);
+        // Format number fields to 2 decimal places if they exist
+        const formattedData = {
+          ...initialData,
+          company: initialData.company || '',  // Ensure company is set
+          msrp: initialData.msrp ? Number(Number(initialData.msrp).toFixed(2)) : undefined,
+          cost_each: initialData.cost_each ? Number(Number(initialData.cost_each).toFixed(2)) : undefined,
+          categories: initialData.categories || []
+        };
+        console.log('Formatted form data:', formattedData);
+        setFormData(formattedData);
+      } else {
+        setFormData(defaultFormData);
+      }
+    }
+  }, [isOpen, initialData, mode]);
+
+  const handleInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const { name, value } = e.target;
+    setFormData(prev => ({ ...prev, [name]: value }));
+  };
+
+  const handleTextAreaChange = (e: React.ChangeEvent<HTMLTextAreaElement>) => {
+    const { name, value } = e.target;
+    setFormData(prev => ({ ...prev, [name]: value }));
+  };
+
+  const handleMultiSelectChange = (name: string, value: string) => {
+    setFormData(prev => {
+      const currentValues = name === 'categories' 
+        ? (prev.categories || [])
+        : [];
+      const valueSet = new Set(currentValues);
+
+      if (valueSet.has(value)) {
+        valueSet.delete(value);
+      } else {
+        valueSet.add(value);
+      }
+
+      return {
+        ...prev,
+        [name]: Array.from(valueSet),
+      };
+    });
+  };
+
+  const handleSelectChange = (name: string, value: string, closePopover = true) => {
+    setFormData(prev => ({ ...prev, [name]: value }));
+    if (closePopover) {
+      // Close the popover by blurring the trigger button
+      const button = document.activeElement as HTMLElement;
+      button?.blur();
+    }
+  };
+
+  const handleNumberInputChange = (e: React.ChangeEvent<HTMLInputElement>) => {
+    const { name, value } = e.target;
+    const numValue = value === '' ? undefined : parseFloat(value);
+    setFormData(prev => ({ ...prev, [name]: numValue }));
+  };
+
+  const handleSubmit = async (e: React.FormEvent) => {
+    e.preventDefault();
+    setIsSubmitting(true);
+
+    try {
+      console.log('Form data before submission:', formData);
+
+      // Validate required fields
+      if (!formData.company || !formData.product_type) {
+        toast.error('Validation failed', {
+          description: 'Company and Product Type are required fields'
+        });
+        setIsSubmitting(false);
+        return;
+      }
+
+      // Create a clean copy of form data without undefined values
+      const cleanFormData = Object.entries(formData).reduce((acc, [key, value]) => {
+        if (value !== undefined && value !== '') {
+          // Handle arrays and array-like fields
+          if (Array.isArray(value)) {
+            // For categories array, always quote values as they are strings
+            if (key === 'categories') {
+              acc[key] = value.length > 0 ? `{${value.map(v => `"${v}"`).join(',')}}` : '{}';
+            } else {
+              // For other arrays, don't quote numeric values
+              acc[key] = value.length > 0 ? `{${value.join(',')}}` : '{}';
+            }
+          } else if (key === 'ship_restrictions') {
+            // Ensure ship_restrictions is always formatted as a PostgreSQL array
+            acc[key] = `{${value}}`;
+          } else if (key === 'tax_cat' || key === 'supplier') {
+            // Convert these fields to numbers
+            acc[key] = Number(value);
+          } else {
+            acc[key] = value;
+          }
+        }
+        return acc;
+      }, {} as Record<string, any>);
+
+      console.log('Clean form data:', cleanFormData);
+
+      // Convert numeric strings to numbers
+      const numericFields = ['msrp', 'cost_each', 'qty_per_unit', 'case_qty', 'weight', 'length', 'width', 'height'];
+      numericFields.forEach(field => {
+        if (cleanFormData[field]) {
+          cleanFormData[field] = Number(cleanFormData[field]);
+        }
+      });
+
+      // Ensure company is a string
+      if (cleanFormData.company) {
+        cleanFormData.company = String(cleanFormData.company);
+      }
+
+      const endpoint = mode === 'edit' ? `/api/templates/${templateId}` : '/api/templates';
+      const method = mode === 'edit' ? 'put' : 'post';
+
+      console.log('Sending request to:', endpoint, 'with data:', cleanFormData);
+
+      const response = await axios[method](endpoint, cleanFormData);
+
+      toast.success(
+        mode === 'edit' ? 'Template updated successfully' : 'Template created successfully'
+      );
+
+      onSuccess();
+      onClose();
+    } catch (error: any) {
+      console.error('Error saving template:', error);
+      console.error('Error response:', error.response?.data);
+      toast.error(
+        'Failed to save template',
+        {
+          description: error.response?.data?.message || error.message || 'An unknown error occurred'
+        }
+      );
+    } finally {
+      setIsSubmitting(false);
+    }
+  };
+
+  // Helper function to sort options with selected value at top
+  const getSortedOptions = (options: FieldOption[], selectedValue?: string | string[]) => {
+    return [...options].sort((a, b) => {
+      if (Array.isArray(selectedValue)) {
+        const aSelected = selectedValue.includes(String(a.value));
+        const bSelected = selectedValue.includes(String(b.value));
+        if (aSelected && !bSelected) return -1;
+        if (!aSelected && bSelected) return 1;
+        return 0;
+      }
+      if (String(a.value) === String(selectedValue)) return -1;
+      if (String(b.value) === String(selectedValue)) return 1;
+      return 0;
+    });
+  };
+
+  // Helper function to get selected category labels
+  const getSelectedCategoryLabels = () => {
+    if (!formData.categories || !Array.isArray(formData.categories) || !formData.categories.length || !fieldOptions) return "";
+    const labels = formData.categories
+      .map(value => fieldOptions.categories.find(cat => cat.value === value)?.label)
+      .filter(Boolean);
+    return labels.join(", ");
+  };
+
+  // Sort categories with selected ones first and respect levels
+  const getSortedCategories = () => {
+    if (!fieldOptions) return [];
+    const selected = new Set(formData.categories || []);
+    
+    // Filter categories to only include types 10, 11, 12, and 13 (proper categories, not themes)
+    const validCategoryTypes = [10, 11, 12, 13];
+    const filteredCategories = fieldOptions.categories.filter(
+      category => category.type && validCategoryTypes.includes(category.type)
+    );
+       
+    return [...filteredCategories].sort((a, b) => {
+      const aSelected = selected.has(a.value);
+      const bSelected = selected.has(b.value);
+      if (aSelected && !bSelected) return -1;
+      if (!aSelected && bSelected) return 1;
+      return 0;
+    });
+  };
+
+  // Add wheel event handler for scrolling
+  const handleWheel = (e: React.WheelEvent) => {
+    const commandList = e.currentTarget;
+    commandList.scrollTop += e.deltaY;
+    e.stopPropagation();
+  };
+
+  // Update the CommandList components to include the wheel handler
+  const renderCommandList = (options: FieldOption[], selectedValue: string | undefined, name: string, closeOnSelect = true) => (
+    <CommandList className="max-h-[200px] overflow-y-auto" onWheel={handleWheel}>
+      <CommandEmpty>No options found.</CommandEmpty>
+      <CommandGroup>
+        {getSortedOptions(options, selectedValue).map((option) => (
+          <CommandItem
+            key={option.value}
+            value={option.label}
+            onSelect={() => {
+              if (name === 'categories') {
+                handleMultiSelectChange(name, option.value);
+              } else {
+                handleSelectChange(name, option.value, closeOnSelect);
+              }
+            }}
+          >
+            {name === 'categories' ? (
+              <div className="flex items-center w-full">
+                <Check
+                  className={cn(
+                    "mr-2 h-4 w-4 flex-shrink-0",
+                    (formData.categories || []).some(cat => String(cat) === String(option.value))
+                      ? "opacity-100"
+                      : "opacity-0"
+                  )}
+                />
+                <span className={cn(
+                  "truncate",
+                  option.level === 1 && "font-bold"
+                )}>
+                  {option.label}
+                </span>
+              </div>
+            ) : (
+              <>
+                <Check
+                  className={cn(
+                    "mr-2 h-4 w-4",
+                    String(selectedValue) === String(option.value)
+                      ? "opacity-100"
+                      : "opacity-0"
+                  )}
+                />
+                {option.label}
+              </>
+            )}
+          </CommandItem>
+        ))}
+      </CommandGroup>
+    </CommandList>
+  );
+
+  // Add logging to company display
+  const getCompanyLabel = (companyId: string | number) => {
+    if (!fieldOptions) return '';
+    const stringId = String(companyId);
+    const company = fieldOptions.companies.find(c => String(c.value) === stringId);
+    console.log('Finding company label for:', companyId, 'Found:', company, 'Available companies:', fieldOptions.companies);
+    return company?.label || stringId;
+  };
+
+  if (!fieldOptions) return null;
+
+  const title = mode === 'edit' 
+    ? 'Edit Template'
+    : mode === 'copy'
+    ? 'Copy Template'
+    : initialData
+    ? 'Create Template from Product'
+    : 'Create Template';
+
+  const description = mode === 'edit'
+    ? 'Edit an existing template. Company and Product Type combination must be unique.'
+    : 'Create a new template for importing products. Company and Product Type combination must be unique.';
+
+  return (
+    <Dialog open={isOpen} onOpenChange={(open) => {
+      if (!open) {
+        setFormData(defaultFormData); // Reset form when closing
+        onClose();
+      }
+    }}>
+      <DialogContent className="max-w-2xl max-h-[95vh] flex flex-col p-6">
+        <DialogHeader className="px-0">
+          <DialogTitle>{title}</DialogTitle>
+          <DialogDescription>{description}</DialogDescription>
+        </DialogHeader>
+        
+        <form onSubmit={handleSubmit} className="flex flex-col flex-1 overflow-hidden">
+          <ScrollArea className="flex-1 -mr-6 pr-6 overflow-y-auto">
+            <div className="grid gap-4 py-4 px-1 pr-4">
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="company">Company*</Label>
+                  <Popover>
+                    <PopoverTrigger asChild>
+                      <Button
+                        variant="outline"
+                        role="combobox"
+                        className={cn(
+                          "w-full justify-between",
+                          !formData.company && "text-muted-foreground"
+                        )}
+                      >
+                        {formData.company
+                          ? getCompanyLabel(formData.company)
+                          : "Select company..."}
+                        <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+                      </Button>
+                    </PopoverTrigger>
+                    <PopoverContent className="w-[var(--radix-popover-trigger-width)] p-0">
+                      <Command>
+                        <CommandInput placeholder="Search companies..." />
+                        {renderCommandList(fieldOptions.companies, formData.company, 'company')}
+                      </Command>
+                    </PopoverContent>
+                  </Popover>
+                </div>
+                
+                <div className="space-y-2">
+                  <Label htmlFor="product_type">Product Type*</Label>
+                  <Input
+                    id="product_type"
+                    name="product_type"
+                    value={formData.product_type}
+                    onChange={handleInputChange}
+                    placeholder="e.g. 'Ephemera' or '12x12 Paper'"
+                  />
+                </div>
+              </div>
+
+              <div className="space-y-2">
+                <Label htmlFor="supplier">Supplier</Label>
+                <Popover>
+                  <PopoverTrigger asChild>
+                    <Button
+                      variant="outline"
+                      role="combobox"
+                      className={cn(
+                        "w-full justify-between",
+                        (!formData.supplier || formData.supplier === "") && "text-muted-foreground"
+                      )}
+                    >
+                      {formData.supplier && formData.supplier !== ""
+                        ? fieldOptions.suppliers.find(
+                            supplier => supplier.value === formData.supplier
+                          )?.label || "Select supplier..."
+                        : "Select supplier..."}
+                      <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent className="w-[var(--radix-popover-trigger-width)] p-0">
+                    <Command>
+                      <CommandInput placeholder="Search suppliers..." />
+                      {renderCommandList(fieldOptions.suppliers, formData.supplier, 'supplier')}
+                    </Command>
+                  </PopoverContent>
+                </Popover>
+              </div>
+
+              <div className="grid grid-cols-4 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="msrp">MSRP</Label>
+                  <Input
+                    id="msrp"
+                    name="msrp"
+                    type="number"
+                    step="0.01"
+                    value={formData.msrp || ""}
+                    onChange={handleNumberInputChange}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="cost_each">Cost Each</Label>
+                  <Input
+                    id="cost_each"
+                    name="cost_each"
+                    type="number"
+                    step="0.01"
+                    value={formData.cost_each || ""}
+                    onChange={handleNumberInputChange}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="qty_per_unit">Quantity per Unit</Label>
+                  <Input
+                    id="qty_per_unit"
+                    name="qty_per_unit"
+                    type="number"
+                    value={formData.qty_per_unit || ""}
+                    onChange={handleNumberInputChange}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="case_qty">Case Quantity</Label>
+                  <Input
+                    id="case_qty"
+                    name="case_qty"
+                    type="number"
+                    value={formData.case_qty || ""}
+                    onChange={handleNumberInputChange}
+                  />
+                </div>
+              </div>
+
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="ship_restrictions">Shipping Restrictions</Label>
+                  <Popover>
+                    <PopoverTrigger asChild>
+                      <Button
+                        variant="outline"
+                        role="combobox"
+                        className={cn(
+                          "w-full justify-between",
+                          !formData.ship_restrictions && "text-muted-foreground"
+                        )}
+                      >
+                        {formData.ship_restrictions
+                          ? fieldOptions.shippingRestrictions.find(
+                              (r) => r.value === formData.ship_restrictions
+                            )?.label
+                          : "Select shipping restriction..."}
+                        <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+                      </Button>
+                    </PopoverTrigger>
+                    <PopoverContent className="w-[var(--radix-popover-trigger-width)] p-0">
+                      <Command>
+                        <CommandInput placeholder="Search restrictions..." />
+                        {renderCommandList(fieldOptions.shippingRestrictions, formData.ship_restrictions, 'ship_restrictions')}
+                      </Command>
+                    </PopoverContent>
+                  </Popover>
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="hts_code">HTS Code</Label>
+                  <Input
+                    id="hts_code"
+                    name="hts_code"
+                    value={formData.hts_code || ""}
+                    onChange={handleInputChange}
+                  />
+                </div>
+              </div>
+
+              <div className="grid grid-cols-4 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="weight">Weight (oz)</Label>
+                  <Input
+                    id="weight"
+                    name="weight"
+                    type="number"
+                    step="0.01"
+                    value={formData.weight || ""}
+                    onChange={handleNumberInputChange}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="length">Length (in)</Label>
+                  <Input
+                    id="length"
+                    name="length"
+                    type="number"
+                    step="0.01"
+                    value={formData.length || ""}
+                    onChange={handleNumberInputChange}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="width">Width (in)</Label>
+                  <Input
+                    id="width"
+                    name="width"
+                    type="number"
+                    step="0.01"
+                    value={formData.width || ""}
+                    onChange={handleNumberInputChange}
+                  />
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="height">Height (in)</Label>
+                  <Input
+                    id="height"
+                    name="height"
+                    type="number"
+                    step="0.01"
+                    value={formData.height || ""}
+                    onChange={handleNumberInputChange}
+                  />
+                </div>
+              </div>
+
+              <div className="grid grid-cols-2 gap-4">
+                <div className="space-y-2">
+                  <Label htmlFor="tax_cat">Tax Category</Label>
+                  <Popover>
+                    <PopoverTrigger asChild>
+                      <Button
+                        variant="outline"
+                        role="combobox"
+                        className={cn(
+                          "w-full justify-between",
+                          formData.tax_cat === undefined && "text-muted-foreground"
+                        )}
+                      >
+                        {formData.tax_cat !== undefined
+                          ? (() => {
+                              console.log('Looking for tax_cat:', {
+                                formData_tax_cat: formData.tax_cat,
+                                formData_tax_cat_type: typeof formData.tax_cat,
+                                taxCategories: fieldOptions.taxCategories.map(cat => ({ 
+                                  value: cat.value, 
+                                  value_type: typeof cat.value,
+                                  label: cat.label
+                                }))
+                              });
+                              const match = fieldOptions.taxCategories.find(
+                                (cat) => String(cat.value) === String(formData.tax_cat)
+                              );
+                              console.log('Tax category match:', match);
+                              return match?.label || "Not Specifically Set";
+                            })()
+                          : "Select tax category..."}
+                        <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+                      </Button>
+                    </PopoverTrigger>
+                    <PopoverContent className="w-[var(--radix-popover-trigger-width)] p-0">
+                      <Command>
+                        <CommandInput placeholder="Search tax categories..." />
+                        {renderCommandList(fieldOptions.taxCategories, formData.tax_cat, 'tax_cat')}
+                      </Command>
+                    </PopoverContent>
+                  </Popover>
+                </div>
+                <div className="space-y-2">
+                  <Label htmlFor="size_cat">Size Category</Label>
+                  <Popover>
+                    <PopoverTrigger asChild>
+                      <Button
+                        variant="outline"
+                        role="combobox"
+                        className={cn(
+                          "w-full justify-between",
+                          !formData.size_cat && "text-muted-foreground"
+                        )}
+                      >
+                        {formData.size_cat
+                          ? fieldOptions.sizes.find(
+                              (size) => size.value === formData.size_cat
+                            )?.label
+                          : "Select size category..."}
+                        <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+                      </Button>
+                    </PopoverTrigger>
+                    <PopoverContent className="w-[var(--radix-popover-trigger-width)] p-0">
+                      <Command>
+                        <CommandInput placeholder="Search sizes..." />
+                        {renderCommandList(fieldOptions.sizes, formData.size_cat, 'size_cat')}
+                      </Command>
+                    </PopoverContent>
+                  </Popover>
+                </div>
+              </div>
+
+              <div className="space-y-2 max-w-[610px]">
+                <Label htmlFor="categories">Categories</Label>
+                <Popover modal={false}>
+                  <PopoverTrigger asChild className="w-full">
+                    <Button
+                      variant="outline"
+                      role="combobox"
+                      className="w-full justify-between"
+                    >
+                      <span className={cn(
+                        "truncate block flex-1 text-left",
+                        !formData.categories?.length && "text-muted-foreground"
+                      )}>
+                        {formData.categories?.length
+                          ? getSelectedCategoryLabels()
+                          : "Select categories..."}
+                      </span>
+                      <ChevronsUpDown className="ml-2 h-4 w-4 shrink-0 opacity-50" />
+                    </Button>
+                  </PopoverTrigger>
+                  <PopoverContent className="w-[var(--radix-popover-trigger-width)] p-0" align="start">
+                    <Command className="max-h-[200px]">
+                      <CommandInput placeholder="Search categories..." />
+                      {renderCommandList(getSortedCategories(), undefined, 'categories', false)}
+                    </Command>
+                  </PopoverContent>
+                </Popover>
+              </div>
+
+              <div className="space-y-2">
+                <Label htmlFor="description">Description</Label>
+                <Textarea
+                  id="description"
+                  name="description"
+                  value={formData.description || ""}
+                  onChange={handleTextAreaChange}
+                  rows={3}
+                />
+              </div>
+            </div>
+          </ScrollArea>
+          
+          <DialogFooter className="px-0 mt-6">
+            <Button type="button" variant="outline" onClick={onClose}>
+              Cancel
+            </Button>
+            <Button type="submit" disabled={isSubmitting}>
+              {isSubmitting && <Loader2 className="mr-2 h-4 w-4 animate-spin" />}
+              {mode === 'edit' ? 'Update' : 'Create'} Template
+            </Button>
+          </DialogFooter>
+        </form>
+      </DialogContent>
+    </Dialog>
+  );
+} 

inventory/src/components/ui/card.tsx

@@ -9,7 +9,7 @@ const Card = React.forwardRef<
   <div
     ref={ref}
     className={cn(
-      "rounded-xl border bg-card text-card-foreground shadow",
+      "rounded-lg border bg-card text-card-foreground shadow-sm",
       className
     )}
     {...props}
@@ -30,22 +30,25 @@ const CardHeader = React.forwardRef<
 CardHeader.displayName = "CardHeader"
 
 const CardTitle = React.forwardRef<
-  HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement>
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLHeadingElement>
 >(({ className, ...props }, ref) => (
-  <div
+  <h3
     ref={ref}
-    className={cn("font-semibold leading-none tracking-tight", className)}
+    className={cn(
+      "text-2xl font-semibold leading-none tracking-tight",
+      className
+    )}
     {...props}
   />
 ))
 CardTitle.displayName = "CardTitle"
 
 const CardDescription = React.forwardRef<
-  HTMLDivElement,
-  React.HTMLAttributes<HTMLDivElement>
+  HTMLParagraphElement,
+  React.HTMLAttributes<HTMLParagraphElement>
 >(({ className, ...props }, ref) => (
-  <div
+  <p
     ref={ref}
     className={cn("text-sm text-muted-foreground", className)}
     {...props}
@@ -73,4 +76,16 @@ const CardFooter = React.forwardRef<
 ))
 CardFooter.displayName = "CardFooter"
 
-export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent }
+const ScrollArea = React.forwardRef<
+  HTMLDivElement,
+  React.HTMLAttributes<HTMLDivElement>
+>(({ className, ...props }, ref) => (
+  <div
+    ref={ref}
+    className={cn("overflow-auto", className)}
+    {...props}
+  />
+))
+ScrollArea.displayName = "ScrollArea"
+
+export { Card, CardHeader, CardFooter, CardTitle, CardDescription, CardContent, ScrollArea }

inventory/src/components/ui/checkbox.tsx

@@ -0,0 +1,28 @@
+import * as React from "react"
+import * as CheckboxPrimitive from "@radix-ui/react-checkbox"
+import { Check } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+const Checkbox = React.forwardRef<
+  React.ElementRef<typeof CheckboxPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof CheckboxPrimitive.Root>
+>(({ className, ...props }, ref) => (
+  <CheckboxPrimitive.Root
+    ref={ref}
+    className={cn(
+      "peer h-4 w-4 shrink-0 rounded-sm border border-primary shadow focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 data-[state=checked]:bg-primary data-[state=checked]:text-primary-foreground",
+      className
+    )}
+    {...props}
+  >
+    <CheckboxPrimitive.Indicator
+      className={cn("flex items-center justify-center text-current")}
+    >
+      <Check className="h-4 w-4" />
+    </CheckboxPrimitive.Indicator>
+  </CheckboxPrimitive.Root>
+))
+Checkbox.displayName = CheckboxPrimitive.Root.displayName
+
+export { Checkbox }

inventory/src/components/ui/code.tsx

@@ -0,0 +1,23 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+export interface CodeProps extends React.HTMLAttributes<HTMLPreElement> {}
+
+const Code = React.forwardRef<HTMLPreElement, CodeProps>(
+  ({ className, ...props }, ref) => {
+    return (
+      <pre
+        ref={ref}
+        className={cn(
+          "rounded-lg bg-muted px-4 py-4 font-mono text-sm",
+          className
+        )}
+        {...props}
+      />
+    )
+  }
+)
+Code.displayName = "Code"
+
+export { Code } 

inventory/src/components/ui/radio-group.tsx

@@ -0,0 +1,44 @@
+"use client"
+
+import * as React from "react"
+import * as RadioGroupPrimitive from "@radix-ui/react-radio-group"
+import { Circle } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+const RadioGroup = React.forwardRef<
+  React.ElementRef<typeof RadioGroupPrimitive.Root>,
+  React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Root>
+>(({ className, ...props }, ref) => {
+  return (
+    <RadioGroupPrimitive.Root
+      className={cn("grid gap-2", className)}
+      {...props}
+      ref={ref}
+    />
+  )
+})
+RadioGroup.displayName = RadioGroupPrimitive.Root.displayName
+
+const RadioGroupItem = React.forwardRef<
+  React.ElementRef<typeof RadioGroupPrimitive.Item>,
+  React.ComponentPropsWithoutRef<typeof RadioGroupPrimitive.Item>
+>(({ className, ...props }, ref) => {
+  return (
+    <RadioGroupPrimitive.Item
+      ref={ref}
+      className={cn(
+        "aspect-square h-4 w-4 rounded-full border border-primary text-primary shadow focus:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50",
+        className
+      )}
+      {...props}
+    >
+      <RadioGroupPrimitive.Indicator className="flex items-center justify-center">
+        <Circle className="h-3.5 w-3.5 fill-primary" />
+      </RadioGroupPrimitive.Indicator>
+    </RadioGroupPrimitive.Item>
+  )
+})
+RadioGroupItem.displayName = RadioGroupPrimitive.Item.displayName
+
+export { RadioGroup, RadioGroupItem }

inventory/src/components/ui/textarea.tsx

@@ -0,0 +1,22 @@
+import * as React from "react"
+
+import { cn } from "@/lib/utils"
+
+const Textarea = React.forwardRef<
+  HTMLTextAreaElement,
+  React.ComponentProps<"textarea">
+>(({ className, ...props }, ref) => {
+  return (
+    <textarea
+      className={cn(
+        "flex min-h-[60px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-base shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm",
+        className
+      )}
+      ref={ref}
+      {...props}
+    />
+  )
+})
+Textarea.displayName = "Textarea"
+
+export { Textarea }

inventory/src/components/ui/toast.tsx

@@ -0,0 +1,127 @@
+import * as React from "react"
+import * as ToastPrimitives from "@radix-ui/react-toast"
+import { cva, type VariantProps } from "class-variance-authority"
+import { X } from "lucide-react"
+
+import { cn } from "@/lib/utils"
+
+const ToastProvider = ToastPrimitives.Provider
+
+const ToastViewport = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Viewport>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Viewport>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Viewport
+    ref={ref}
+    className={cn(
+      "fixed top-0 z-[100] flex max-h-screen w-full flex-col-reverse p-4 sm:bottom-0 sm:right-0 sm:top-auto sm:flex-col md:max-w-[420px]",
+      className
+    )}
+    {...props}
+  />
+))
+ToastViewport.displayName = ToastPrimitives.Viewport.displayName
+
+const toastVariants = cva(
+  "group pointer-events-auto relative flex w-full items-center justify-between space-x-2 overflow-hidden rounded-md border p-4 pr-6 shadow-lg transition-all data-[swipe=cancel]:translate-x-0 data-[swipe=end]:translate-x-[var(--radix-toast-swipe-end-x)] data-[swipe=move]:translate-x-[var(--radix-toast-swipe-move-x)] data-[swipe=move]:transition-none data-[state=open]:animate-in data-[state=closed]:animate-out data-[swipe=end]:animate-out data-[state=closed]:fade-out-80 data-[state=closed]:slide-out-to-right-full data-[state=open]:slide-in-from-top-full data-[state=open]:sm:slide-in-from-bottom-full",
+  {
+    variants: {
+      variant: {
+        default: "border bg-background text-foreground",
+        destructive:
+          "destructive group border-destructive bg-destructive text-destructive-foreground",
+      },
+    },
+    defaultVariants: {
+      variant: "default",
+    },
+  }
+)
+
+const Toast = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Root>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Root> &
+    VariantProps<typeof toastVariants>
+>(({ className, variant, ...props }, ref) => {
+  return (
+    <ToastPrimitives.Root
+      ref={ref}
+      className={cn(toastVariants({ variant }), className)}
+      {...props}
+    />
+  )
+})
+Toast.displayName = ToastPrimitives.Root.displayName
+
+const ToastAction = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Action>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Action>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Action
+    ref={ref}
+    className={cn(
+      "inline-flex h-8 shrink-0 items-center justify-center rounded-md border bg-transparent px-3 text-sm font-medium transition-colors hover:bg-secondary focus:outline-none focus:ring-1 focus:ring-ring disabled:pointer-events-none disabled:opacity-50 group-[.destructive]:border-muted/40 group-[.destructive]:hover:border-destructive/30 group-[.destructive]:hover:bg-destructive group-[.destructive]:hover:text-destructive-foreground group-[.destructive]:focus:ring-destructive",
+      className
+    )}
+    {...props}
+  />
+))
+ToastAction.displayName = ToastPrimitives.Action.displayName
+
+const ToastClose = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Close>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Close>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Close
+    ref={ref}
+    className={cn(
+      "absolute right-1 top-1 rounded-md p-1 text-foreground/50 opacity-0 transition-opacity hover:text-foreground focus:opacity-100 focus:outline-none focus:ring-1 group-hover:opacity-100 group-[.destructive]:text-red-300 group-[.destructive]:hover:text-red-50 group-[.destructive]:focus:ring-red-400 group-[.destructive]:focus:ring-offset-red-600",
+      className
+    )}
+    toast-close=""
+    {...props}
+  >
+    <X className="h-4 w-4" />
+  </ToastPrimitives.Close>
+))
+ToastClose.displayName = ToastPrimitives.Close.displayName
+
+const ToastTitle = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Title>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Title>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Title
+    ref={ref}
+    className={cn("text-sm font-semibold [&+div]:text-xs", className)}
+    {...props}
+  />
+))
+ToastTitle.displayName = ToastPrimitives.Title.displayName
+
+const ToastDescription = React.forwardRef<
+  React.ElementRef<typeof ToastPrimitives.Description>,
+  React.ComponentPropsWithoutRef<typeof ToastPrimitives.Description>
+>(({ className, ...props }, ref) => (
+  <ToastPrimitives.Description
+    ref={ref}
+    className={cn("text-sm opacity-90", className)}
+    {...props}
+  />
+))
+ToastDescription.displayName = ToastPrimitives.Description.displayName
+
+type ToastProps = React.ComponentPropsWithoutRef<typeof Toast>
+
+type ToastActionElement = React.ReactElement<typeof ToastAction>
+
+export {
+  type ToastProps,
+  type ToastActionElement,
+  ToastProvider,
+  ToastViewport,
+  Toast,
+  ToastTitle,
+  ToastDescription,
+  ToastClose,
+  ToastAction,
+}

inventory/src/components/ui/toaster.tsx

@@ -0,0 +1,33 @@
+import { useToast } from "@/hooks/use-toast"
+import {
+  Toast,
+  ToastClose,
+  ToastDescription,
+  ToastProvider,
+  ToastTitle,
+  ToastViewport,
+} from "@/components/ui/toast"
+
+export function Toaster() {
+  const { toasts } = useToast()
+
+  return (
+    <ToastProvider>
+      {toasts.map(function ({ id, title, description, action, ...props }) {
+        return (
+          <Toast key={id} {...props}>
+            <div className="grid gap-1">
+              {title && <ToastTitle>{title}</ToastTitle>}
+              {description && (
+                <ToastDescription>{description}</ToastDescription>
+              )}
+            </div>
+            {action}
+            <ToastClose />
+          </Toast>
+        )
+      })}
+      <ToastViewport />
+    </ToastProvider>
+  )
+}

inventory/src/hooks/use-toast.ts

@@ -0,0 +1,194 @@
+"use client"
+
+// Inspired by react-hot-toast library
+import * as React from "react"
+
+import type {
+  ToastActionElement,
+  ToastProps,
+} from "@/components/ui/toast"
+
+const TOAST_LIMIT = 1
+const TOAST_REMOVE_DELAY = 1000000
+
+type ToasterToast = ToastProps & {
+  id: string
+  title?: React.ReactNode
+  description?: React.ReactNode
+  action?: ToastActionElement
+}
+
+const actionTypes = {
+  ADD_TOAST: "ADD_TOAST",
+  UPDATE_TOAST: "UPDATE_TOAST",
+  DISMISS_TOAST: "DISMISS_TOAST",
+  REMOVE_TOAST: "REMOVE_TOAST",
+} as const
+
+let count = 0
+
+function genId() {
+  count = (count + 1) % Number.MAX_SAFE_INTEGER
+  return count.toString()
+}
+
+type ActionType = typeof actionTypes
+
+type Action =
+  | {
+      type: ActionType["ADD_TOAST"]
+      toast: ToasterToast
+    }
+  | {
+      type: ActionType["UPDATE_TOAST"]
+      toast: Partial<ToasterToast>
+    }
+  | {
+      type: ActionType["DISMISS_TOAST"]
+      toastId?: ToasterToast["id"]
+    }
+  | {
+      type: ActionType["REMOVE_TOAST"]
+      toastId?: ToasterToast["id"]
+    }
+
+interface State {
+  toasts: ToasterToast[]
+}
+
+const toastTimeouts = new Map<string, ReturnType<typeof setTimeout>>()
+
+const addToRemoveQueue = (toastId: string) => {
+  if (toastTimeouts.has(toastId)) {
+    return
+  }
+
+  const timeout = setTimeout(() => {
+    toastTimeouts.delete(toastId)
+    dispatch({
+      type: "REMOVE_TOAST",
+      toastId: toastId,
+    })
+  }, TOAST_REMOVE_DELAY)
+
+  toastTimeouts.set(toastId, timeout)
+}
+
+export const reducer = (state: State, action: Action): State => {
+  switch (action.type) {
+    case "ADD_TOAST":
+      return {
+        ...state,
+        toasts: [action.toast, ...state.toasts].slice(0, TOAST_LIMIT),
+      }
+
+    case "UPDATE_TOAST":
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === action.toast.id ? { ...t, ...action.toast } : t
+        ),
+      }
+
+    case "DISMISS_TOAST": {
+      const { toastId } = action
+
+      // ! Side effects ! - This could be extracted into a dismissToast() action,
+      // but I'll keep it here for simplicity
+      if (toastId) {
+        addToRemoveQueue(toastId)
+      } else {
+        state.toasts.forEach((toast) => {
+          addToRemoveQueue(toast.id)
+        })
+      }
+
+      return {
+        ...state,
+        toasts: state.toasts.map((t) =>
+          t.id === toastId || toastId === undefined
+            ? {
+                ...t,
+                open: false,
+              }
+            : t
+        ),
+      }
+    }
+    case "REMOVE_TOAST":
+      if (action.toastId === undefined) {
+        return {
+          ...state,
+          toasts: [],
+        }
+      }
+      return {
+        ...state,
+        toasts: state.toasts.filter((t) => t.id !== action.toastId),
+      }
+  }
+}
+
+const listeners: Array<(state: State) => void> = []
+
+let memoryState: State = { toasts: [] }
+
+function dispatch(action: Action) {
+  memoryState = reducer(memoryState, action)
+  listeners.forEach((listener) => {
+    listener(memoryState)
+  })
+}
+
+type Toast = Omit<ToasterToast, "id">
+
+function toast({ ...props }: Toast) {
+  const id = genId()
+
+  const update = (props: ToasterToast) =>
+    dispatch({
+      type: "UPDATE_TOAST",
+      toast: { ...props, id },
+    })
+  const dismiss = () => dispatch({ type: "DISMISS_TOAST", toastId: id })
+
+  dispatch({
+    type: "ADD_TOAST",
+    toast: {
+      ...props,
+      id,
+      open: true,
+      onOpenChange: (open) => {
+        if (!open) dismiss()
+      },
+    },
+  })
+
+  return {
+    id: id,
+    dismiss,
+    update,
+  }
+}
+
+function useToast() {
+  const [state, setState] = React.useState<State>(memoryState)
+
+  React.useEffect(() => {
+    listeners.push(setState)
+    return () => {
+      const index = listeners.indexOf(setState)
+      if (index > -1) {
+        listeners.splice(index, 1)
+      }
+    }
+  }, [state])
+
+  return {
+    ...state,
+    toast,
+    dismiss: (toastId?: string) => dispatch({ type: "DISMISS_TOAST", toastId }),
+  }
+}
+
+export { useToast, toast }

inventory/src/index.css

@@ -99,3 +99,14 @@
     @apply bg-background text-foreground;
   }
 }
+
+
+
+@layer base {
+  * {
+    @apply border-border outline-ring/50;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}

inventory/src/lib/react-spreadsheet-import/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 UGNIS,
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

inventory/src/lib/react-spreadsheet-import/README.md

@@ -0,0 +1,341 @@
+<h1 align="center">RSI react-spreadsheet-import ⚡️</h1>
+
+<div align="center">
+  
+![GitHub Workflow Status](https://img.shields.io/github/actions/workflow/status/UgnisSoftware/react-spreadsheet-import/test.yaml)
+![GitHub](https://img.shields.io/github/license/UgnisSoftware/react-spreadsheet-import) [![npm](https://img.shields.io/npm/v/react-spreadsheet-import)](https://www.npmjs.com/package/react-spreadsheet-import)
+  
+</div>
+<br />
+
+A component used for importing XLS / XLSX / CSV documents built with [**Chakra UI**](https://chakra-ui.com). Import flow combines:
+
+- 📥 Uploader
+- ⚙️ Parser
+- 📊 File preview
+- 🧪 UI for column mapping
+- ✏ UI for validating and editing data
+
+✨ [**Demo**](https://ugnissoftware.github.io/react-spreadsheet-import/iframe.html?id=react-spreadsheet-import--basic&args=&viewMode=story) ✨
+<br />
+
+## Features
+
+- Custom styles - edit Chakra UI theme to match your project's styles 🎨
+- Custom validation rules - make sure valid data is being imported, easily spot and correct errors
+- Hooks - alter raw data after upload or make adjustments on data changes
+- Auto-mapping columns - automatically map most likely value to your template values, e.g. `name` -> `firstName`
+  <br />
+
+![rsi-preview](https://user-images.githubusercontent.com/45755753/159503528-90aacb69-128f-4ece-b45b-ab97d403a9d3.gif)
+
+## Figma
+
+We provide full figma designs. You can copy the designs
+[here](https://www.figma.com/community/file/1080776795891439629)
+
+## Getting started
+
+```sh
+npm i react-spreadsheet-import
+```
+
+Using the component: (it's up to you when the flow is open and what you do on submit with the imported data)
+
+```tsx
+import { ReactSpreadsheetImport } from "react-spreadsheet-import";
+
+<ReactSpreadsheetImport isOpen={isOpen} onClose={onClose} onSubmit={onSubmit} fields={fields} />
+```
+
+## Required Props
+
+```tsx
+  // Determines if modal is visible.
+  isOpen: Boolean
+  // Called when flow is closed without reaching submit.
+  onClose: () => void
+  // Called after user completes the flow. Provides data array, where data keys matches your field keys. 
+  onSubmit: (data, file) => void | Promise<any>
+```
+
+### Fields
+
+Fields describe what data you are trying to collect.
+
+```tsx
+const fields = [
+  {
+    // Visible in table header and when matching columns.
+    label: "Name",
+    // This is the key used for this field when we call onSubmit.
+    key: "name",
+    // Allows for better automatic column matching. Optional.
+    alternateMatches: ["first name", "first"],
+    // Used when editing and validating information.
+    fieldType: {
+      // There are 3 types - "input" / "checkbox" / "select".
+      type: "input",
+    },
+    // Used in the first step to provide an example of what data is expected in this field. Optional.
+    example: "Stephanie",
+    // Can have multiple validations that are visible in Validation Step table.
+    validations: [
+      {
+        // Can be "required" / "unique" / "regex"
+        rule: "required",
+        errorMessage: "Name is required",
+        // There can be "info" / "warning" / "error" levels. Optional. Default "error".
+        level: "error",
+      },
+    ],
+  },
+] as const
+```
+
+## Optional Props
+
+### Hooks
+
+You can transform and validate data with custom hooks. There are hooks after each step:
+
+- **uploadStepHook** - runs only once after uploading the file.
+- **selectHeaderStepHook** - runs only once after selecting the header row in spreadsheet.
+- **matchColumnsStepHook** - runs only once after column matching. Operations on data that are expensive should be done here.
+
+The last step - validation step has 2 unique hooks that run only in that step with different performance tradeoffs:
+
+- **tableHook** - runs at the start and on any change. Runs on all rows. Very expensive, but can change rows that depend on other rows.
+- **rowHook** - runs at the start and on any row change. Runs only on the rows changed. Fastest, most validations and transformations should be done here.
+
+Example:
+
+```tsx
+<ReactSpreadsheetImport
+  rowHook={(data, addError) => {
+    // Validation
+    if (data.name === "John") {
+      addError("name", { message: "No Johns allowed", level: "info" })
+    }
+    // Transformation
+    return { ...data, name: "Not John" }
+    // Sorry John
+  }}
+/>
+```
+
+### Initial state
+
+In rare case when you need to skip the beginning of the flow, you can start the flow from any of the steps.
+
+- **initialStepState** - initial state of component that will be rendered on load. 
+
+```tsx
+  initialStepState?: StepState
+  
+  type StepState =
+    | {
+        type: StepType.upload
+      }
+    | {
+        type: StepType.selectSheet
+        workbook: XLSX.WorkBook
+      }
+    | {
+        type: StepType.selectHeader
+        data: RawData[]
+      }
+    | {
+        type: StepType.matchColumns
+        data: RawData[]
+        headerValues: RawData
+      }
+    | {
+        type: StepType.validateData
+        data: any[]
+      }
+
+  type RawData = Array<string | undefined>
+
+  // XLSX.workbook type is native to SheetJS and can be viewed here: https://github.com/SheetJS/sheetjs/blob/83ddb4c1203f6bac052d8c1608b32fead02ea32f/types/index.d.ts#L269
+```
+
+Example:
+
+```tsx
+import { ReactSpreadsheetImport, StepType } from "react-spreadsheet-import";
+
+<ReactSpreadsheetImport
+  initialStepState={{
+    type: StepType.matchColumns,
+    data: [
+      ["Josh", "2"],
+      ["Charlie", "3"],
+      ["Lena", "50"],
+    ],
+    headerValues: ["name", "age"],
+  }}
+/>
+```
+
+### Dates and time
+
+Excel stores dates and times as numbers - offsets from an epoch. When reading xlsx files SheetJS provides date formatting helpers.
+**Default date import format** is `yyyy-mm-dd`. Date parsing with SheetJS sometimes yields unexpected results, therefore thorough date validations are recommended.
+
+- **dateFormat** - sets SheetJS `dateNF` option. Can be used to format dates when importing sheet data.
+- **parseRaw** - sets SheetJS `raw` option. If `true`, date formatting will be applied to XLSX date fields only. Default is `true`
+
+Common date-time formats can be viewed [here](https://docs.sheetjs.com/docs/csf/features/dates/#date-and-time-number-formats).
+
+### Other optional props
+
+```tsx
+  // Allows submitting with errors. Default: true
+  allowInvalidSubmit?: boolean
+  // Translations for each text. See customisation bellow
+  translations?: object
+  // Theme configuration passed to underlying Chakra-UI. See customisation bellow
+  customTheme?: object
+  // Specifies maximum number of rows for a single import
+  maxRecords?: number
+  // Maximum upload filesize (in bytes)
+  maxFileSize?: number
+  // Automatically map imported headers to specified fields if possible. Default: true
+  autoMapHeaders?: boolean
+  // When field type is "select", automatically match values if possible. Default: false
+  autoMapSelectValues?: boolean
+  // Headers matching accuracy: 1 for strict and up for more flexible matching. Default: 2
+  autoMapDistance?: number
+  // Enable navigation in stepper component and show back button. Default: false
+  isNavigationEnabled?: boolean
+```
+
+## Customisation
+
+### Customising styles (colors, fonts)
+
+You can see default theme we use [here](https://github.com/UgnisSoftware/react-spreadsheet-import/blob/master/src/theme.ts). Your override should match this object's structure.
+
+There are 3 ways you can style the component:
+
+1.) Change theme colors globally
+
+```jsx
+    <ReactSpreadsheetImport
+        {...mockRsiValues}
+        isOpen={isOpen}
+        onClose={onClose}
+        onSubmit={setData}
+        customTheme={{
+          colors: {
+            background: 'white',
+            ...
+            rsi: {
+              // your brand colors should go here
+              50: '...'
+              ...
+              500: 'teal',
+              ...
+              900: "...",
+            },
+          },
+        }}
+      />
+```
+
+<img width="1189" alt="Screenshot 2022-04-13 at 10 24 34" src="https://user-images.githubusercontent.com/5903616/163123718-15c05ad8-243b-4a81-8141-c47216047468.png">
+
+2.) Change all components of the same type, like all Buttons, at the same time
+
+```jsx
+<ReactSpreadsheetImport
+  {...mockRsiValues}
+  isOpen={isOpen}
+  onClose={onClose}
+  onSubmit={setData}
+  customTheme={{
+    components: {
+      Button: {
+        baseStyle: {
+          borderRadius: "none",
+        },
+        defaultProps: {
+          colorScheme: "yellow",
+        },
+      },
+    },
+  }}
+/>
+```
+
+<img width="1191" alt="Screenshot 2022-04-13 at 11 04 30" src="https://user-images.githubusercontent.com/5903616/163130213-82f955b4-5081-49e0-8f43-8857d480dacd.png">
+ 
+3.) Change components specifically in each Step.
+```jsx
+    <ReactSpreadsheetImport
+        {...mockRsiValues}
+        isOpen={isOpen}
+        onClose={onClose}
+        onSubmit={setData}
+        customTheme={{
+          components: {
+            UploadStep: {
+              baseStyle: {
+                dropzoneButton: {
+                  bg: "red",
+                },
+              },
+            },
+          },
+        }}
+      />
+```
+<img width="1182" alt="Screenshot 2022-04-13 at 10 21 58" src="https://user-images.githubusercontent.com/5903616/163123694-5b79179e-037e-4f9d-b1a9-6078f758bb7e.png">
+
+Underneath we use Chakra-UI, you can send in a custom theme for us to apply. Read more about themes [here](https://chakra-ui.com/docs/styled-system/theming/theme)
+
+### Changing text (translations)
+
+You can change any text in the flow:
+
+```tsx
+<ReactSpreadsheetImport
+  translations={{
+    uploadStep: {
+      title: "Upload Employees",
+    },
+  }}
+/>
+```
+
+You can see all the translation keys [here](https://github.com/UgnisSoftware/react-spreadsheet-import/blob/master/src/translationsRSIProps.ts)
+
+## VS other libraries
+
+Flatfile vs react-spreadsheet-import and Dromo vs react-spreadsheet-import:
+
+|                                | RSI            | Flatfile    | Dromo       |
+| ------------------------------ | -------------- | ----------- | ----------- |
+| Licence                        | MIT            | Proprietary | Proprietary |
+| Price                          | Free           | Paid        | Paid        |
+| Support                        | Github Issues  | Enterprise  | Enterprise  |
+| Self-host                      | Yes            | Paid        | Paid        |
+| Hosted solution                | In development | Yes         | Yes         |
+| On-prem deployment             | N/A            | Yes         | Yes         |
+| Hooks                          | Yes            | Yes         | Yes         |
+| Automatic header matching      | Yes            | Yes         | Yes         |
+| Data validation                | Yes            | Yes         | Yes         |
+| Custom styling                 | Yes            | Yes         | Yes         |
+| Translations                   | Yes            | Yes         | Yes         |
+| Trademarked words `Data Hooks` | No             | Yes         | No          |
+
+React-spreadsheet-import can be used as a free and open-source alternative to Flatfile and Dromo.
+
+## Contributing
+
+Feel free to open issues if you have any questions or notice bugs. If you want different component behaviour, consider forking the project.
+
+## Credits
+
+Created by Ugnis. [Julita Kriauciunaite](https://github.com/JulitorK) and [Karolis Masiulis](https://github.com/masiulis). You can contact us at `info@ugnis.com`

inventory/src/lib/react-spreadsheet-import/package.json

@@ -0,0 +1,174 @@
+{
+  "name": "react-spreadsheet-import",
+  "version": "4.7.1",
+  "description": "React spreadsheet import for xlsx and csv files with column matching and validation",
+  "main": "./dist-commonjs/index.js",
+  "module": "./dist/index.js",
+  "types": "./types/index.d.ts",
+  "files": [
+    "dist-commonjs",
+    "dist",
+    "types"
+  ],
+  "scripts": {
+    "start": "storybook dev -p 6006",
+    "test:unit": "jest",
+    "test:e2e": "npx playwright test",
+    "test:chromatic": "npx chromatic ",
+    "ts": "tsc",
+    "lint": "eslint \"src/**/*.{ts,tsx}\"",
+    "lint:fix": "eslint \"src/**/*.{ts,tsx}\" --fix",
+    "prebuild": "npm run clean",
+    "build": "rollup -c rollup.config.ts",
+    "build-storybook": "storybook build -o docs-build",
+    "release:patch": "git checkout master && git pull && npm run test:unit && npm run ts && npm run build && npm version patch && git add -A && git push && git push --tags && npm publish",
+    "release:minor": "git checkout master && git pull && npm run test:unit && npm run ts && npm run build && npm version minor && git add -A && git push && git push --tags && npm publish",
+    "release:major": "git checkout master && git pull && npm run test:unit && npm run ts && npm run build && npm version major && git add -A && git push && git push --tags && npm publish",
+    "clean": "rimraf dist dist-commonjs types"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/UgnisSoftware/react-spreadsheet-import.git"
+  },
+  "keywords": [
+    "React",
+    "spreadsheet",
+    "import",
+    "upload",
+    "csv",
+    "xlsx",
+    "validate",
+    "automatic",
+    "match"
+  ],
+  "author": {
+    "name": "Ugnis"
+  },
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/UgnisSoftware/react-spreadsheet-import/issues"
+  },
+  "homepage": "https://github.com/UgnisSoftware/react-spreadsheet-import#readme",
+  "peerDependencies": {
+    "react": ">=18",
+    "react-dom": ">=18"
+  },
+  "dependencies": {
+    "@chakra-ui/react": "^2.8.1",
+    "@emotion/react": "^11.11.1",
+    "@emotion/styled": "^11.11.0",
+    "chakra-react-select": "^4.7.5",
+    "chakra-ui-steps": "2.0.4",
+    "framer-motion": "^10.16.4",
+    "js-levenshtein": "1.1.6",
+    "lodash": "4.17.21",
+    "react-data-grid": "7.0.0-beta.13",
+    "react-dropzone": "14.2.3",
+    "react-icons": "4.11.0",
+    "uuid": "^9.0.1",
+    "xlsx-ugnis": "0.20.3"
+  },
+  "devDependencies": {
+    "@babel/core": "7.23.2",
+    "@babel/preset-env": "7.23.2",
+    "@babel/preset-react": "7.22.15",
+    "@babel/preset-typescript": "7.23.2",
+    "@emotion/jest": "11.11.0",
+    "@jest/types": "27.5.1",
+    "@playwright/test": "^1.39.0",
+    "@storybook/addon-essentials": "7.5.1",
+    "@storybook/addon-interactions": "7.5.1",
+    "@storybook/addon-links": "7.5.1",
+    "@storybook/blocks": "7.5.1",
+    "@storybook/cli": "7.5.1",
+    "@storybook/react": "7.5.1",
+    "@storybook/react-webpack5": "7.5.1",
+    "@storybook/testing-library": "^0.0.14-next.2",
+    "@testing-library/dom": "9.3.0",
+    "@testing-library/jest-dom": "5.16.5",
+    "@testing-library/react": "14.0.0",
+    "@testing-library/user-event": "14.4.3",
+    "@types/jest": "27.4.1",
+    "@types/js-levenshtein": "1.1.1",
+    "@types/node": "^20.8.7",
+    "@types/react": "18.2.6",
+    "@types/react-dom": "18.2.4",
+    "@types/styled-system": "5.1.16",
+    "@types/uuid": "9.0.1",
+    "@typescript-eslint/eslint-plugin": "5.59.7",
+    "@typescript-eslint/parser": "5.59.7",
+    "babel-loader": "9.1.3",
+    "chromatic": "^7.4.0",
+    "eslint": "8.41.0",
+    "eslint-config-prettier": "8.8.0",
+    "eslint-plugin-prettier": "4.2.1",
+    "eslint-plugin-react": "7.32.2",
+    "eslint-plugin-react-hooks": "4.6.0",
+    "jest": "27.5.1",
+    "jest-watch-typeahead": "1.0.0",
+    "lint-staged": "13.2.2",
+    "prettier": "2.8.8",
+    "prop-types": "15.8.1",
+    "react": "18.2.0",
+    "react-dom": "18.2.0",
+    "react-select-event": "5.5.1",
+    "rollup": "2.70.1",
+    "rollup-plugin-typescript2": "0.31.2",
+    "storybook": "7.5.1",
+    "ts-essentials": "9.3.2",
+    "ts-jest": "27.1.4",
+    "ttypescript": "1.5.15",
+    "typescript": "4.9.5",
+    "typescript-transform-paths": "3.4.6"
+  },
+  "overrides": {
+    "semver": "^7.5.3"
+  },
+  "lint-staged": {
+    "*.{ts,tsx}": "eslint",
+    "*.{js,ts,tsx,md,html,css,json}": "prettier --write"
+  },
+  "prettier": {
+    "tabWidth": 2,
+    "trailingComma": "all",
+    "semi": false,
+    "printWidth": 120
+  },
+  "jest": {
+    "preset": "ts-jest",
+    "testEnvironment": "jsdom",
+    "moduleFileExtensions": [
+      "ts",
+      "tsx",
+      "js",
+      "jsx",
+      "mjs"
+    ],
+    "transform": {
+      "^.+\\.(ts|tsx)?$": "ts-jest/dist",
+      "^.+\\.mjs$": "ts-jest/dist"
+    },
+    "moduleNameMapper": {
+      "~/(.*)": "<rootDir>/src/$1"
+    },
+    "modulePathIgnorePatterns": [
+      "<rootDir>/e2e/"
+    ],
+    "transformIgnorePatterns": [
+      "[/\\\\]node_modules[/\\\\].+\\.(js|jsx|mjs)$"
+    ],
+    "setupFiles": [
+      "./src/tests/setup.ts"
+    ],
+    "globals": {
+      "ts-jest": {
+        "tsconfig": "tsconfig.json"
+      }
+    },
+    "watchPlugins": [
+      "jest-watch-typeahead/filename",
+      "jest-watch-typeahead/testname"
+    ]
+  },
+  "readme": "ERROR: No README data found!"
+}

inventory/src/lib/react-spreadsheet-import/src/ReactSpreadsheetImport.tsx

@@ -0,0 +1,41 @@
+import merge from "lodash/merge"
+
+import { Steps } from "./steps/Steps"
+import { rtlThemeSupport, themeOverrides } from "./theme"
+import { Providers } from "./components/Providers"
+import type { RsiProps } from "./types"
+import { ModalWrapper } from "./components/ModalWrapper"
+import { translations } from "./translationsRSIProps"
+
+export const defaultTheme = themeOverrides
+
+export const defaultRSIProps: Partial<RsiProps<any>> = {
+  autoMapHeaders: true,
+  autoMapSelectValues: false,
+  allowInvalidSubmit: true,
+  autoMapDistance: 2,
+  isNavigationEnabled: false,
+  translations: translations,
+  uploadStepHook: async (value) => value,
+  selectHeaderStepHook: async (headerValues, data) => ({ headerValues, data }),
+  matchColumnsStepHook: async (table) => table,
+  dateFormat: "yyyy-mm-dd", // ISO 8601,
+  parseRaw: true,
+} as const
+
+export const ReactSpreadsheetImport = <T extends string>(propsWithoutDefaults: RsiProps<T>) => {
+  const props = merge({}, defaultRSIProps, propsWithoutDefaults)
+  const mergedTranslations =
+    props.translations !== translations ? merge(translations, props.translations) : translations
+  const mergedThemes = props.rtl
+    ? merge(defaultTheme, rtlThemeSupport, props.customTheme)
+    : merge(defaultTheme, props.customTheme)
+
+  return (
+    <Providers theme={mergedThemes} rsiValues={{ ...props, translations: mergedTranslations }}>
+      <ModalWrapper isOpen={props.isOpen} onClose={props.onClose}>
+        <Steps />
+      </ModalWrapper>
+    </Providers>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/components/ModalWrapper.tsx

@@ -0,0 +1,88 @@
+import type React from "react"
+import {
+  Dialog,
+  DialogContent,
+  DialogOverlay,
+  DialogPortal,
+  DialogClose,
+} from "@/components/ui/dialog"
+import {
+  AlertDialog,
+  AlertDialogAction,
+  AlertDialogCancel,
+  AlertDialogContent,
+  AlertDialogDescription,
+  AlertDialogFooter,
+  AlertDialogHeader,
+  AlertDialogTitle,
+  AlertDialogTrigger,
+  AlertDialogPortal,
+  AlertDialogOverlay,
+} from "@/components/ui/alert-dialog"
+import { useRsi } from "../hooks/useRsi"
+import { useState } from "react"
+
+type Props = {
+  children: React.ReactNode
+  isOpen: boolean
+  onClose: () => void
+}
+
+export const ModalWrapper = ({ children, isOpen, onClose }: Props) => {
+  const { rtl, translations } = useRsi()
+  const [showCloseAlert, setShowCloseAlert] = useState(false)
+  
+  return (
+    <>
+      <Dialog open={isOpen} onOpenChange={() => setShowCloseAlert(true)} modal>
+        <DialogPortal>
+          <DialogOverlay className="bg-background/80 backdrop-blur-sm" />
+          <DialogContent
+            onEscapeKeyDown={(e) => {
+              e.preventDefault()
+              setShowCloseAlert(true)
+            }}
+            onPointerDownOutside={(e) => e.preventDefault()}
+            className="fixed left-[50%] top-[50%] translate-x-[-50%] translate-y-[-50%] w-[calc(100%-2rem)] h-[calc(100%-2rem)] max-w-[100vw] max-h-[100vh] flex flex-col overflow-hidden rounded-lg border bg-background p-0 shadow-lg sm:w-[calc(100%-3rem)] sm:h-[calc(100%-3rem)] md:w-[calc(100%-4rem)] md:h-[calc(100%-4rem)]"
+          >
+            <AlertDialog>
+              <AlertDialogTrigger asChild>
+                <DialogClose className="absolute right-4 top-4" onClick={(e) => {
+                  e.preventDefault()
+                  setShowCloseAlert(true)
+                }} />
+              </AlertDialogTrigger>
+            </AlertDialog>
+            <div dir={rtl ? "rtl" : "ltr"} className="flex-1 overflow-auto">
+              {children}
+            </div>
+          </DialogContent>
+        </DialogPortal>
+      </Dialog>
+
+      <AlertDialog open={showCloseAlert} onOpenChange={setShowCloseAlert}>
+        <AlertDialogPortal>
+          <AlertDialogOverlay className="z-[1400]" />
+          <AlertDialogContent className="z-[1500]">
+            <AlertDialogHeader>
+              <AlertDialogTitle>
+                {translations.alerts.confirmClose.headerTitle}
+              </AlertDialogTitle>
+              <AlertDialogDescription>
+                {translations.alerts.confirmClose.bodyText}
+              </AlertDialogDescription>
+            </AlertDialogHeader>
+            <AlertDialogFooter>
+              <AlertDialogCancel onClick={() => setShowCloseAlert(false)}>
+                {translations.alerts.confirmClose.cancelButtonTitle}
+              </AlertDialogCancel>
+              <AlertDialogAction onClick={onClose}>
+                {translations.alerts.confirmClose.exitButtonTitle}
+              </AlertDialogAction>
+            </AlertDialogFooter>
+          </AlertDialogContent>
+        </AlertDialogPortal>
+      </AlertDialog>
+    </>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/components/Providers.tsx

@@ -0,0 +1,33 @@
+import { ChakraProvider, extendTheme } from "@chakra-ui/react"
+import { createContext } from "react"
+import type { RsiProps } from "../types"
+import type { CustomTheme } from "../theme"
+
+export const RsiContext = createContext({} as any)
+
+type ProvidersProps<T extends string> = {
+  children: React.ReactNode
+  theme: CustomTheme
+  rsiValues: RsiProps<T>
+}
+
+export const rootId = "chakra-modal-rsi"
+
+export const Providers = <T extends string>({ children, theme, rsiValues }: ProvidersProps<T>) => {
+  const mergedTheme = extendTheme(theme)
+
+  if (!rsiValues.fields) {
+    throw new Error("Fields must be provided to react-spreadsheet-import")
+  }
+
+  return (
+    <RsiContext.Provider value={rsiValues}>
+      <ChakraProvider>
+        {/* cssVarsRoot used to override RSI defaultTheme but not the rest of chakra defaultTheme */}
+        <ChakraProvider cssVarsRoot={`#${rootId}`} theme={mergedTheme}>
+          {children}
+        </ChakraProvider>
+      </ChakraProvider>
+    </RsiContext.Provider>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/components/Table.tsx

@@ -0,0 +1,23 @@
+import type { DataGridProps, Column } from "react-data-grid"
+import DataGrid from "react-data-grid"
+import { useRsi } from "../hooks/useRsi"
+
+export type { Column }
+
+export type Props<TRow> = DataGridProps<TRow> & {
+  rowHeight?: number
+  hiddenHeader?: boolean
+  className?: string
+  style?: React.CSSProperties
+}
+
+export const Table = <TRow,>({ className, ...props }: Props<TRow>) => {
+  const { rtl } = useRsi()
+  return (
+    <DataGrid 
+      className={"rdg-light " + (className || "")} 
+      direction={rtl ? "rtl" : "ltr"} 
+      {...props} 
+    />
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/hooks/useRsi.ts

@@ -0,0 +1,9 @@
+import { useContext } from "react"
+import { RsiContext } from "../components/Providers"
+import type { RsiProps } from "../types"
+import type { MarkRequired } from "ts-essentials"
+import type { defaultRSIProps } from "../ReactSpreadsheetImport"
+import type { Translations } from "../translationsRSIProps"
+
+export const useRsi = <T extends string>() =>
+  useContext<MarkRequired<RsiProps<T>, keyof typeof defaultRSIProps> & { translations: Translations }>(RsiContext)

inventory/src/lib/react-spreadsheet-import/src/index.ts

@@ -0,0 +1,2 @@
+export { StepType } from "./steps/UploadFlow"
+export { ReactSpreadsheetImport } from "./ReactSpreadsheetImport"

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/components/MatchIcon.tsx

@@ -0,0 +1,42 @@
+import { chakra, useStyleConfig, Flex } from "@chakra-ui/react"
+import { dataAttr } from "@chakra-ui/utils"
+import { motion } from "framer-motion"
+import { CgCheck } from "react-icons/cg"
+
+const MotionFlex = motion(Flex)
+
+const animationConfig = {
+  transition: {
+    duration: 0.1,
+  },
+  exit: { scale: 0.5, opacity: 0 },
+  initial: { scale: 0.5, opacity: 0 },
+  animate: { scale: 1, opacity: 1 },
+}
+type MatchIconProps = {
+  isChecked: boolean
+}
+
+export const MatchIcon = (props: MatchIconProps) => {
+  const style = useStyleConfig("MatchIcon", props)
+
+  return (
+    <chakra.div
+      __css={style}
+      minW={6}
+      minH={6}
+      w={6}
+      h={6}
+      ml="0.875rem"
+      mr={3}
+      data-highlighted={dataAttr(props.isChecked)}
+      data-testid="column-checkmark"
+    >
+      {props.isChecked && (
+        <MotionFlex {...animationConfig}>
+          <CgCheck size="24px" />
+        </MotionFlex>
+      )}
+    </chakra.div>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/components/TemplateColumn.tsx

@@ -0,0 +1,133 @@
+import { useRsi } from "../../../hooks/useRsi"
+import type { Column } from "../MatchColumnsStep"
+import { ColumnType } from "../MatchColumnsStep"
+import type { Fields } from "../../../types"
+import {
+  Card,
+  CardContent,
+  CardHeader,
+} from "@/components/ui/card"
+import {
+  Select,
+  SelectContent,
+  SelectItem,
+  SelectTrigger,
+  SelectValue,
+} from "@/components/ui/select"
+import {
+  Accordion,
+  AccordionContent,
+  AccordionItem,
+  AccordionTrigger,
+} from "@/components/ui/accordion"
+import { Check } from "lucide-react"
+
+type TemplateColumnProps<T extends string> = {
+  column: Column<T>
+  onChange: (value: T, columnIndex: number) => void
+  onSubChange: (value: string, columnIndex: number, entry: string) => void
+}
+
+const getAccordionTitle = <T extends string>(fields: Fields<T>, column: Column<T>, translations: any) => {
+  const field = fields.find((f) => "value" in column && f.key === column.value)
+  if (!field) return ""
+  return `${translations.matchColumnsStep.matchDropdownTitle} ${field.label} (${
+    "matchedOptions" in column ? column.matchedOptions.filter((option) => !option.value).length : 0
+  } ${translations.matchColumnsStep.unmatched})`
+}
+
+export const TemplateColumn = <T extends string>({ column, onChange, onSubChange }: TemplateColumnProps<T>) => {
+  const { translations, fields } = useRsi<T>()
+  const isIgnored = column.type === ColumnType.ignored
+  const isChecked =
+    column.type === ColumnType.matched ||
+    column.type === ColumnType.matchedCheckbox ||
+    column.type === ColumnType.matchedSelectOptions
+  const isSelect = "matchedOptions" in column
+  const selectOptions = fields.map(({ label, key }) => ({ value: key, label }))
+  const selectValue = column.type === ColumnType.empty ? undefined : 
+    selectOptions.find(({ value }) => "value" in column && column.value === value)?.value
+
+  if (isIgnored) {
+    return null
+  }
+
+  return (
+    <Card className="h-full">
+      <CardHeader className="flex flex-row items-center justify-between space-x-2 p-4">
+        <div className="flex-1">
+          <Select
+            key={`select-${column.index}-${("value" in column ? column.value : "empty")}`}
+            value={selectValue}
+            onValueChange={(value) => onChange(value as T, column.index)}
+          >
+            <SelectTrigger className="w-full">
+              <SelectValue placeholder={translations.matchColumnsStep.selectPlaceholder} />
+            </SelectTrigger>
+            <SelectContent 
+              side="bottom"
+              align="start"
+              className="z-[1500]"
+            >
+              {selectOptions.map((option) => (
+                <SelectItem key={option.value} value={option.value}>
+                  {option.label}
+                </SelectItem>
+              ))}
+            </SelectContent>
+          </Select>
+        </div>
+        {isChecked && (
+          <div className="flex h-8 w-8 items-center justify-center rounded-full border border-green-700 bg-green-300 dark:bg-green-900/20">
+            <Check className="h-4 w-4 text-green-700 dark:text-green-500" />
+          </div>
+        )}
+      </CardHeader>
+      {isSelect && (
+        <CardContent className="p-4">
+          <Accordion type="multiple" className="w-full">
+            <AccordionItem value="options" className="border-none">
+              <AccordionTrigger className="py-2 text-sm hover:no-underline">
+                {getAccordionTitle(fields, column, translations)}
+              </AccordionTrigger>
+              <AccordionContent>
+                <div className="space-y-2">
+                  {column.matchedOptions.map((option) => (
+                    <div key={option.entry} className="space-y-1">
+                      <p className="text-sm text-muted-foreground">
+                        {option.entry}
+                      </p>
+                      <Select
+                        value={option.value}
+                        onValueChange={(value) => onSubChange(value, column.index, option.entry!)}
+                      >
+                        <SelectTrigger className="w-full">
+                          <SelectValue placeholder={translations.matchColumnsStep.subSelectPlaceholder} />
+                        </SelectTrigger>
+                        <SelectContent 
+                          side="bottom"
+                          align="start"
+                          className="z-[1000]"
+                        >
+                          {(() => {
+                            const field = fields.find((f) => "value" in column && f.key === column.value)
+                            if (!field || !("fieldType" in field) || !("options" in field.fieldType)) return null
+                            return field.fieldType.options.map((option) => (
+                              <SelectItem key={option.value} value={option.value}>
+                                {option.label}
+                              </SelectItem>
+                            ))
+                          })()}
+                        </SelectContent>
+                      </Select>
+                    </div>
+                  ))}
+                </div>
+              </AccordionContent>
+            </AccordionItem>
+          </Accordion>
+        </CardContent>
+      )}
+    </Card>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/findMatch.ts

@@ -0,0 +1,27 @@
+import lavenstein from "js-levenshtein"
+import type { Fields } from "../../../types"
+
+type AutoMatchAccumulator<T> = {
+  distance: number
+  value: T
+}
+
+export const findMatch = <T extends string>(
+  header: string,
+  fields: Fields<T>,
+  autoMapDistance: number,
+): T | undefined => {
+  const headerLower = header.toLowerCase()
+  const smallestValue = fields.reduce<AutoMatchAccumulator<T>>((acc, field) => {
+    const distance = Math.min(
+      ...[
+        lavenstein(field.key.toLowerCase(), headerLower),
+        ...(field.alternateMatches?.map((alternate) => lavenstein(alternate.toLowerCase(), headerLower)) || []),
+      ],
+    )
+    return distance < acc.distance || acc.distance === undefined
+      ? ({ value: field.key, distance } as AutoMatchAccumulator<T>)
+      : acc
+  }, {} as AutoMatchAccumulator<T>)
+  return smallestValue.distance <= autoMapDistance ? smallestValue.value : undefined
+}

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/findUnmatchedRequiredFields.ts

@@ -0,0 +1,15 @@
+import type { Fields } from "../../../types"
+import type { Columns } from "../MatchColumnsStep"
+
+export const findUnmatchedRequiredFields = <T extends string>(fields: Fields<T>, columns: Columns<T>) => {
+  // Get all required fields
+  const requiredFields = fields
+    .filter((field) => field.validations?.some((validation: any) => 
+      validation.rule === "required" || validation.required === true
+    ))
+  
+  // Find which required fields are not matched in columns
+  return requiredFields
+    .filter((field) => columns.findIndex((column) => "value" in column && column.value === field.key) === -1)
+    .map((field) => field.key) || []
+}

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/getFieldOptions.ts

@@ -0,0 +1,6 @@
+import type { Fields } from "../../../types"
+
+export const getFieldOptions = <T extends string>(fields: Fields<T>, fieldKey: string) => {
+  const field = fields.find(({ key }) => fieldKey === key)!
+  return field.fieldType.type === "select" ? field.fieldType.options : []
+}

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/getMatchedColumns.ts

@@ -0,0 +1,41 @@
+import lavenstein from "js-levenshtein"
+import { findMatch } from "./findMatch"
+import type { Field, Fields } from "../../../types"
+import { setColumn } from "./setColumn"
+import type { Column, Columns } from "../MatchColumnsStep"
+import type { MatchColumnsProps } from "../MatchColumnsStep"
+
+export const getMatchedColumns = <T extends string>(
+  columns: Columns<T>,
+  fields: Fields<T>,
+  data: MatchColumnsProps<T>["data"],
+  autoMapDistance: number,
+  autoMapSelectValues?: boolean,
+) =>
+  columns.reduce<Column<T>[]>((arr, column) => {
+    const autoMatch = findMatch(column.header, fields, autoMapDistance)
+    if (autoMatch) {
+      const field = fields.find((field) => field.key === autoMatch) as Field<T>
+      const duplicateIndex = arr.findIndex((column) => "value" in column && column.value === field.key)
+      const duplicate = arr[duplicateIndex]
+      if (duplicate && "value" in duplicate) {
+        return lavenstein(duplicate.value, duplicate.header) < lavenstein(autoMatch, column.header)
+          ? [
+              ...arr.slice(0, duplicateIndex),
+              setColumn(arr[duplicateIndex], field, data, autoMapSelectValues),
+              ...arr.slice(duplicateIndex + 1),
+              setColumn(column),
+            ]
+          : [
+              ...arr.slice(0, duplicateIndex),
+              setColumn(arr[duplicateIndex]),
+              ...arr.slice(duplicateIndex + 1),
+              setColumn(column, field, data, autoMapSelectValues),
+            ]
+      } else {
+        return [...arr, setColumn(column, field, data, autoMapSelectValues)]
+      }
+    } else {
+      return [...arr, column]
+    }
+  }, [])

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/normalizeCheckboxValue.ts

@@ -0,0 +1,13 @@
+const booleanWhitelist: Record<string, boolean> = {
+  yes: true,
+  no: false,
+  true: true,
+  false: false,
+}
+
+export const normalizeCheckboxValue = (value: string | undefined): boolean => {
+  if (value && value.toLowerCase() in booleanWhitelist) {
+    return booleanWhitelist[value.toLowerCase()]
+  }
+  return false
+}

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/normalizeTableData.ts

@@ -0,0 +1,67 @@
+import type { Columns } from "../MatchColumnsStep"
+import { ColumnType } from "../MatchColumnsStep"
+import type { Data, Fields, RawData } from "../../../types"
+import { normalizeCheckboxValue } from "./normalizeCheckboxValue"
+
+export const normalizeTableData = <T extends string>(columns: Columns<T>, data: RawData[], fields: Fields<T>) =>
+  data.map((row) =>
+    columns.reduce((acc, column, index) => {
+      const curr = row[index]
+      switch (column.type) {
+        case ColumnType.matchedCheckbox: {
+          const field = fields.find((field) => field.key === column.value)!
+          if ("booleanMatches" in field.fieldType && Object.keys(field.fieldType).length) {
+            const booleanMatchKey = Object.keys(field.fieldType.booleanMatches || []).find(
+              (key) => key.toLowerCase() === curr?.toLowerCase(),
+            )!
+            const booleanMatch = field.fieldType.booleanMatches?.[booleanMatchKey]
+            acc[column.value] = (booleanMatchKey ? booleanMatch : normalizeCheckboxValue(curr)) as Data<T>[T]
+          } else {
+            acc[column.value] = normalizeCheckboxValue(curr) as Data<T>[T]
+          }
+          return acc
+        }
+        case ColumnType.matched: {
+          acc[column.value] = (curr === "" ? undefined : curr) as Data<T>[T]
+          return acc
+        }
+        case ColumnType.matchedMultiInput: {
+          const field = fields.find((field) => field.key === column.value)!
+          if (curr) {
+            const separator = field.fieldType.type === "multi-input" ? field.fieldType.separator || "," : ","
+            acc[column.value] = curr.split(separator).map(v => v.trim()).filter(Boolean) as Data<T>[T]
+          } else {
+            acc[column.value] = undefined as Data<T>[T]
+          }
+          return acc
+        }
+        case ColumnType.matchedSelect:
+        case ColumnType.matchedSelectOptions: {
+          const matchedOption = column.matchedOptions.find(({ entry }) => entry === curr)
+          acc[column.value] = (matchedOption?.value || undefined) as Data<T>[T]
+          return acc
+        }
+        case ColumnType.matchedMultiSelect: {
+          const field = fields.find((field) => field.key === column.value)!
+          if (curr) {
+            const separator = field.fieldType.type === "multi-select" ? field.fieldType.separator || "," : ","
+            const entries = curr.split(separator).map(v => v.trim()).filter(Boolean)
+            const values = entries.map(entry => {
+              const matchedOption = column.matchedOptions.find(({ entry: optEntry }) => optEntry === entry)
+              return matchedOption?.value
+            }).filter(Boolean) as string[]
+            acc[column.value] = (values.length ? values : undefined) as Data<T>[T]
+          } else {
+            acc[column.value] = undefined as Data<T>[T]
+          }
+          return acc
+        }
+        case ColumnType.empty:
+        case ColumnType.ignored: {
+          return acc
+        }
+        default:
+          return acc
+      }
+    }, {} as Data<T>),
+  )

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/setColumn.ts

@@ -0,0 +1,65 @@
+import type { Field, MultiSelect } from "../../../types"
+import { Column, ColumnType, MatchColumnsProps, MatchedOptions } from "../MatchColumnsStep"
+import { uniqueEntries } from "./uniqueEntries"
+
+export const setColumn = <T extends string>(
+  oldColumn: Column<T>,
+  field?: Field<T>,
+  data?: MatchColumnsProps<T>["data"],
+  autoMapSelectValues?: boolean,
+): Column<T> => {
+  switch (field?.fieldType.type) {
+    case "select":
+      const fieldOptions = field.fieldType.options
+      const uniqueData = uniqueEntries(data || [], oldColumn.index) as MatchedOptions<T>[]
+      const matchedOptions = autoMapSelectValues
+        ? uniqueData.map((record) => {
+            const value = fieldOptions.find(
+              (fieldOption) => fieldOption.value === record.entry || fieldOption.label === record.entry,
+            )?.value
+            return value ? ({ ...record, value } as MatchedOptions<T>) : (record as MatchedOptions<T>)
+          })
+        : uniqueData
+      const allMatched = matchedOptions.filter((o) => o.value).length == uniqueData?.length
+
+      return {
+        ...oldColumn,
+        type: allMatched ? ColumnType.matchedSelectOptions : ColumnType.matchedSelect,
+        value: field.key,
+        matchedOptions,
+      }
+    case "multi-select":
+      const multiSelectFieldType = field.fieldType as MultiSelect
+      const multiSelectFieldOptions = multiSelectFieldType.options
+      const multiSelectUniqueData = uniqueEntries(data || [], oldColumn.index) as MatchedOptions<T>[]
+      const multiSelectMatchedOptions = autoMapSelectValues
+        ? multiSelectUniqueData.map((record) => {
+            // Split the entry by the separator (default to comma)
+            const entries = record.entry.split(multiSelectFieldType.separator || ",").map(e => e.trim())
+            // Try to match each entry to an option
+            const values = entries.map(entry => {
+              const value = multiSelectFieldOptions.find(
+                (fieldOption) => fieldOption.value === entry || fieldOption.label === entry,
+              )?.value
+              return value
+            }).filter(Boolean) as T[]
+            return { ...record, value: values.length ? values[0] : undefined } as MatchedOptions<T>
+          })
+        : multiSelectUniqueData
+
+      return {
+        ...oldColumn,
+        type: ColumnType.matchedMultiSelect,
+        value: field.key,
+        matchedOptions: multiSelectMatchedOptions,
+      }
+    case "checkbox":
+      return { index: oldColumn.index, type: ColumnType.matchedCheckbox, value: field.key, header: oldColumn.header }
+    case "input":
+      return { index: oldColumn.index, type: ColumnType.matched, value: field.key, header: oldColumn.header }
+    case "multi-input":
+      return { index: oldColumn.index, type: ColumnType.matchedMultiInput, value: field.key, header: oldColumn.header }
+    default:
+      return { index: oldColumn.index, header: oldColumn.header, type: ColumnType.empty }
+  }
+}

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/setIgnoreColumn.ts

@@ -0,0 +1,7 @@
+import { Column, ColumnType } from "../MatchColumnsStep"
+
+export const setIgnoreColumn = <T extends string>({ header, index }: Column<T>): Column<T> => ({
+  header,
+  index,
+  type: ColumnType.ignored,
+})

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/setSubColumn.ts

@@ -0,0 +1,20 @@
+import { ColumnType, MatchedOptions, MatchedSelectColumn, MatchedSelectOptionsColumn, MatchedMultiSelectColumn } from "../MatchColumnsStep"
+
+export const setSubColumn = <T>(
+  oldColumn: MatchedSelectColumn<T> | MatchedSelectOptionsColumn<T> | MatchedMultiSelectColumn<T>,
+  entry: string,
+  value: string,
+): MatchedSelectColumn<T> | MatchedSelectOptionsColumn<T> | MatchedMultiSelectColumn<T> => {
+  const options = oldColumn.matchedOptions.map((option) => (option.entry === entry ? { ...option, value } : option))
+  const allMatched = options.every(({ value }) => !!value)
+
+  if (oldColumn.type === ColumnType.matchedMultiSelect) {
+    return { ...oldColumn, matchedOptions: options as MatchedOptions<T>[] }
+  }
+  
+  if (allMatched) {
+    return { ...oldColumn, matchedOptions: options as MatchedOptions<T>[], type: ColumnType.matchedSelectOptions }
+  } else {
+    return { ...oldColumn, matchedOptions: options as MatchedOptions<T>[], type: ColumnType.matchedSelect }
+  }
+}

inventory/src/lib/react-spreadsheet-import/src/steps/MatchColumnsStep/utils/uniqueEntries.ts

@@ -0,0 +1,11 @@
+import uniqBy from "lodash/uniqBy"
+import type { MatchColumnsProps, MatchedOptions } from "../MatchColumnsStep"
+
+export const uniqueEntries = <T extends string>(
+  data: MatchColumnsProps<T>["data"],
+  index: number,
+): Partial<MatchedOptions<T>>[] =>
+  uniqBy(
+    data.map((row) => ({ entry: row[index] })),
+    "entry",
+  ).filter(({ entry }) => !!entry)

inventory/src/lib/react-spreadsheet-import/src/steps/SelectHeaderStep/SelectHeaderStep.tsx

@@ -0,0 +1,194 @@
+import { useCallback, useState } from "react"
+import { SelectHeaderTable } from "./components/SelectHeaderTable"
+import { useRsi } from "../../hooks/useRsi"
+import type { RawData } from "../../types"
+import { Button } from "@/components/ui/button"
+import { useToast } from "@/hooks/use-toast"
+
+type SelectHeaderProps = {
+  data: RawData[]
+  onContinue: (headerValues: RawData, data: RawData[]) => Promise<void>
+  onBack?: () => void
+}
+
+export const SelectHeaderStep = ({ data, onContinue, onBack }: SelectHeaderProps) => {
+  const { translations } = useRsi()
+  const { toast } = useToast()
+  const [selectedRows, setSelectedRows] = useState<ReadonlySet<number>>(new Set([0]))
+  const [isLoading, setIsLoading] = useState(false)
+  const [localData, setLocalData] = useState<RawData[]>(data)
+
+  const handleContinue = useCallback(async () => {
+    const [selectedRowIndex] = selectedRows
+    // We consider data above header to be redundant
+    const trimmedData = localData.slice(selectedRowIndex + 1)
+    setIsLoading(true)
+    await onContinue(localData[selectedRowIndex], trimmedData)
+    setIsLoading(false)
+  }, [onContinue, localData, selectedRows])
+
+  const discardEmptyAndDuplicateRows = useCallback(() => {
+    // Helper function to count non-empty values in a row
+    const countNonEmptyValues = (values: Record<string, any>): number => {
+      return Object.values(values).filter(val => 
+        val !== undefined && 
+        val !== null && 
+        (typeof val === 'string' ? val.trim() !== '' : true)
+      ).length;
+    };
+
+    // Helper function to normalize row values for case-insensitive comparison
+    const normalizeRowForComparison = (row: Record<string, any>): Record<string, any> => {
+      return Object.entries(row).reduce((acc, [key, value]) => {
+        // Convert string values to lowercase for case-insensitive comparison
+        if (typeof value === 'string') {
+          acc[key.toLowerCase()] = value.toLowerCase().trim();
+        } else {
+          acc[key.toLowerCase()] = value;
+        }
+        return acc;
+      }, {} as Record<string, any>);
+    };
+
+    // First, analyze all rows to determine if we have rows with multiple values
+    const rowsWithValues = localData.map(row => {
+      return countNonEmptyValues(row);
+    });
+
+    // Check if we have any rows with more than one value
+    const hasMultiValueRows = rowsWithValues.some(count => count > 1);
+
+    // Get the selected header row
+    const [selectedRowIndex] = selectedRows;
+    const selectedHeaderRow = localData[selectedRowIndex];
+    
+    // Debug: Log the selected header row
+    console.log("Selected header row:", selectedHeaderRow);
+    
+    const normalizedHeaderRow = normalizeRowForComparison(selectedHeaderRow);
+    
+    // Debug: Log the normalized header row
+    console.log("Normalized header row:", normalizedHeaderRow);
+    
+    const selectedHeaderStr = JSON.stringify(Object.entries(normalizedHeaderRow).sort());
+
+    // Filter out empty rows, rows with single values (if we have multi-value rows),
+    // and duplicate rows (including duplicates of the header row)
+    const seen = new Set<string>();
+    // Add the selected header row to the seen set first
+    seen.add(selectedHeaderStr);
+
+    // Debug: Track which rows are being removed and why
+    const removedRows: { index: number; reason: string; row: any }[] = [];
+
+    const filteredRows = localData.filter((row, index) => {
+      // Always keep the selected header row
+      if (index === selectedRowIndex) {
+        return true;
+      }
+
+      // Check if it's empty or has only one value
+      const nonEmptyCount = rowsWithValues[index];
+      if (nonEmptyCount === 0 || (hasMultiValueRows && nonEmptyCount <= 1)) {
+        removedRows.push({ index, reason: "Empty or single value", row });
+        return false;
+      }
+
+      // Check if it's a duplicate (case-insensitive)
+      const normalizedRow = normalizeRowForComparison(row);
+      
+      // Debug: If this row might be a duplicate of the header, log it
+      if (index < 5 || index === selectedRowIndex + 1 || index === selectedRowIndex - 1) {
+        console.log(`Row ${index} normalized:`, normalizedRow);
+      }
+      
+      const rowStr = JSON.stringify(Object.entries(normalizedRow).sort());
+      
+      if (seen.has(rowStr)) {
+        removedRows.push({ 
+          index, 
+          reason: "Duplicate", 
+          row
+        });
+        return false;
+      }
+      
+      seen.add(rowStr);
+      return true;
+    });
+
+    // Debug: Log removed rows
+    console.log("Removed rows:", removedRows);
+
+    // Only update if we actually removed any rows
+    if (filteredRows.length < localData.length) {
+      // Adjust the selected row index if needed
+      const newSelectedIndex = filteredRows.findIndex(row => 
+        JSON.stringify(Object.entries(normalizeRowForComparison(row)).sort()) === selectedHeaderStr
+      );
+      
+      // Debug: Log the new selected index
+      console.log("New selected index:", newSelectedIndex);
+      
+      setLocalData(filteredRows);
+      setSelectedRows(new Set([newSelectedIndex]));
+      
+      toast({
+        title: "Rows removed",
+        description: `Removed ${localData.length - filteredRows.length} empty, single-value, or duplicate rows`,
+        variant: "default"
+      });
+    } else {
+      toast({
+        title: "No rows removed",
+        description: "No empty, single-value, or duplicate rows were found",
+        variant: "default"
+      });
+    }
+  }, [localData, selectedRows, toast]);
+
+  return (
+    <div className="flex flex-col h-[calc(100vh-9.5rem)]">
+      <div className="px-8 py-6 bg-background flex justify-between items-end">
+        <div>
+          <h2 className="text-2xl font-semibold text-foreground">
+            {translations.selectHeaderStep.title}
+          </h2>
+          <p className="mt-1 text-sm text-muted-foreground">
+            Select the row that contains your column headers
+          </p>
+        </div>
+        <Button
+          variant="secondary"
+          size="sm"
+          onClick={discardEmptyAndDuplicateRows}
+        >
+          Remove Empty/Duplicates
+        </Button>
+      </div>
+      <div className="flex-1 flex flex-col min-h-0">
+        <div className="px-8 flex-1 overflow-auto">
+          <SelectHeaderTable 
+            data={localData} 
+            selectedRows={selectedRows} 
+            setSelectedRows={setSelectedRows} 
+          />
+        </div>
+      </div>
+      <div className="flex items-center justify-between border-t bg-muted px-8 py-4 mt-2">
+        {onBack && (
+          <Button variant="outline" onClick={onBack}>
+            {translations.selectHeaderStep.backButtonTitle}
+          </Button>
+        )}
+        <Button 
+          className="ml-auto"
+          disabled={isLoading}
+          onClick={handleContinue}
+        >
+          {translations.selectHeaderStep.nextButtonTitle}
+        </Button>
+      </div>
+    </div>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/steps/SelectHeaderStep/components/SelectHeaderTable.tsx

@@ -0,0 +1,104 @@
+import { useMemo } from "react"
+import type { RawData } from "../../../types"
+import {
+  Table,
+  TableBody,
+  TableCell,
+  TableHead,
+  TableHeader,
+  TableRow,
+} from "@/components/ui/table"
+import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group"
+import { Label } from "@/components/ui/label"
+import { cn } from "@/lib/utils"
+
+interface Props {
+  data: RawData[]
+  selectedRows: ReadonlySet<number>
+  setSelectedRows: (rows: ReadonlySet<number>) => void
+}
+
+export const SelectHeaderTable = ({ data, selectedRows, setSelectedRows }: Props) => {
+  const columns = useMemo(() => {
+    const longestRowLength = data.reduce((acc, curr) => (acc > curr.length ? acc : curr.length), 0)
+    return Array.from(Array(longestRowLength), (_, index) => ({
+      key: index.toString(),
+      name: `Column ${index + 1}`,
+    }))
+  }, [data])
+
+  if (!data || data.length === 0) {
+    return (
+      <div className="p-4">
+        <p className="text-sm text-muted-foreground">No data available to select headers from.</p>
+      </div>
+    )
+  }
+
+  const selectedRowIndex = Array.from(selectedRows)[0]
+  const gridTemplateColumns = `60px repeat(${columns.length}, minmax(150px, 300px))`
+
+  return (
+    <div className="rounded-md border p-3">
+
+      <div className="h-[calc(100vh-23rem)] overflow-auto">
+        <Table className="relative w-full" style={{ tableLayout: 'fixed' }}>
+          <TableHeader>
+            <TableRow className="grid" style={{ gridTemplateColumns }}>
+              <TableHead className="sticky top-0 z-20 bg-background overflow-hidden">
+
+              </TableHead>
+              {columns.map((column) => (
+                <TableHead 
+                  key={column.key}
+                  className="sticky top-0 z-20 bg-background overflow-hidden"
+                >
+                  <div className="truncate">
+                    {column.name}
+                  </div>
+                </TableHead>
+              ))}
+            </TableRow>
+          </TableHeader>
+          <TableBody>
+            <RadioGroup
+              value={selectedRowIndex?.toString()}
+              onValueChange={(value) => setSelectedRows(new Set([parseInt(value)]))}
+            >
+              {data.map((row, rowIndex) => (
+                <TableRow 
+                  key={rowIndex}
+                  className={cn(
+                    "grid",
+                    selectedRowIndex === rowIndex && "bg-muted font-bold",
+                    "group hover:bg-muted/50"
+                  )}
+                  style={{ gridTemplateColumns }}
+                >
+                  <TableCell className="overflow-hidden">
+                    <div className="flex items-center">
+                      <RadioGroupItem value={rowIndex.toString()} id={`row-${rowIndex}`} />
+                      <Label htmlFor={`row-${rowIndex}`} className="sr-only">
+                        Select as header row
+                      </Label>
+                    </div>
+                  </TableCell>
+                  {columns.map((column, colIndex) => (
+                    <TableCell 
+                      key={`${rowIndex}-${column.key}`}
+                      className="overflow-hidden"
+                    >
+                      <div className="truncate">
+                        {row[colIndex] || ""}
+                      </div>
+                    </TableCell>
+                  ))}
+                </TableRow>
+              ))}
+            </RadioGroup>
+          </TableBody>
+        </Table>
+      </div>
+    </div>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/steps/SelectHeaderStep/components/columns.tsx

@@ -0,0 +1,67 @@
+import { Column, FormatterProps, useRowSelection } from "react-data-grid"
+import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group"
+import { Label } from "@/components/ui/label"
+import type { RawData } from "../../../types"
+
+const SELECT_COLUMN_KEY = "select-row"
+
+function SelectFormatter(props: FormatterProps<unknown>) {
+  const [isRowSelected, onRowSelectionChange] = useRowSelection()
+
+  return (
+    <div className="flex h-full items-center pl-2">
+      <RadioGroup defaultValue={isRowSelected ? "selected" : undefined}>
+        <div className="flex items-center space-x-2">
+          <RadioGroupItem
+            value="selected"
+            id={`row-${props.rowIdx}`}
+            checked={isRowSelected}
+            onClick={(event) => {
+              onRowSelectionChange({
+                row: props.row,
+                checked: !isRowSelected,
+                isShiftClick: (event.nativeEvent as MouseEvent).shiftKey,
+              })
+            }}
+          />
+          <Label
+            htmlFor={`row-${props.rowIdx}`}
+            className="sr-only"
+          >
+            Select as header row
+          </Label>
+        </div>
+      </RadioGroup>
+    </div>
+  )
+}
+
+export const SelectColumn: Column<any, any> = {
+  key: SELECT_COLUMN_KEY,
+  name: "Select Header",
+  width: 100,
+  minWidth: 100,
+  maxWidth: 100,
+  resizable: false,
+  sortable: false,
+  frozen: true,
+  cellClass: "rdg-radio",
+  formatter: SelectFormatter,
+}
+
+export const generateSelectionColumns = (data: RawData[]) => {
+  const longestRowLength = data.reduce((acc, curr) => (acc > curr.length ? acc : curr.length), 0)
+  return [
+    SelectColumn,
+    ...Array.from(Array(longestRowLength), (_, index) => ({
+      key: index.toString(),
+      name: `Column ${index + 1}`,
+      width: 150,
+      formatter: ({ row }: { row: RawData }) => (
+        <div className="p-2 overflow-hidden text-ellipsis whitespace-nowrap">
+          {row[index]}
+        </div>
+      ),
+    })),
+  ]
+}

inventory/src/lib/react-spreadsheet-import/src/steps/SelectSheetStep/SelectSheetStep.tsx

@@ -0,0 +1,77 @@
+import { useCallback, useState } from "react"
+import { useRsi } from "../../hooks/useRsi"
+import { RadioGroup, RadioGroupItem } from "@/components/ui/radio-group"
+import { Label } from "@/components/ui/label"
+import { Button } from "@/components/ui/button"
+import { ChevronLeft } from "lucide-react"
+
+type SelectSheetProps = {
+  sheetNames: string[]
+  onContinue: (sheetName: string) => Promise<void>
+  onBack?: () => void
+}
+
+export const SelectSheetStep = ({ sheetNames, onContinue, onBack }: SelectSheetProps) => {
+  const [isLoading, setIsLoading] = useState(false)
+  const { translations } = useRsi()
+  const [value, setValue] = useState(sheetNames[0])
+
+  const handleOnContinue = useCallback(
+    async (data: typeof value) => {
+      setIsLoading(true)
+      await onContinue(data)
+      setIsLoading(false)
+    },
+    [onContinue],
+  )
+
+  return (
+    <div className="flex h-[calc(100vh-10rem)] flex-col">
+      <div className="flex-1 overflow-hidden">
+        <div className="px-8 py-6">
+          <div className="mb-8">
+            <h2 className="text-3xl font-semibold text-foreground">
+              {translations.uploadStep.selectSheet.title}
+            </h2>
+          </div>
+          <RadioGroup
+            value={value}
+            onValueChange={setValue}
+            className="space-y-4"
+          >
+            {sheetNames.map((sheetName) => (
+              <div key={sheetName} className="flex items-center space-x-2">
+                <RadioGroupItem value={sheetName} id={sheetName} />
+                <Label
+                  htmlFor={sheetName}
+                  className="text-base"
+                >
+                  {sheetName}
+                </Label>
+              </div>
+            ))}
+          </RadioGroup>
+        </div>
+      </div>
+      <div className="flex items-center justify-between border-t px-8 py-4 bg-muted -mb-1">
+        {onBack && (
+          <Button
+            variant="ghost"
+            onClick={onBack}
+            className="gap-2"
+          >
+            <ChevronLeft className="h-4 w-4" />
+            {translations.uploadStep.selectSheet.backButtonTitle}
+          </Button>
+        )}
+        <div className="flex-1" />
+        <Button
+          onClick={() => handleOnContinue(value)}
+          disabled={isLoading}
+        >
+          {translations.uploadStep.selectSheet.nextButtonTitle}
+        </Button>
+      </div>
+    </div>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/steps/Steps.tsx

@@ -0,0 +1,88 @@
+import { StepState, StepType, UploadFlow } from "./UploadFlow"
+import { useRsi } from "../hooks/useRsi"
+import { useRef, useState } from "react"
+import { steps, stepTypeToStepIndex, stepIndexToStepType } from "../utils/steps"
+import { CgCheck } from "react-icons/cg"
+
+const CheckIcon = ({ color }: { color: string }) => <CgCheck size="24" className={color} />
+
+export const Steps = () => {
+  const { initialStepState, translations, isNavigationEnabled } = useRsi()
+  const initialStep = stepTypeToStepIndex(initialStepState?.type)
+  const [activeStep, setActiveStep] = useState(initialStep)
+  const [state, setState] = useState<StepState>(initialStepState || { type: StepType.upload })
+  const history = useRef<StepState[]>([])
+
+  const onClickStep = (stepIndex: number) => {
+    const type = stepIndexToStepType(stepIndex)
+    const historyIdx = history.current.findIndex((v) => v.type === type)
+    if (historyIdx === -1) return
+    const nextHistory = history.current.slice(0, historyIdx + 1)
+    history.current = nextHistory
+    setState(nextHistory[nextHistory.length - 1])
+    setActiveStep(stepIndex)
+  }
+
+  const onBack = () => {
+    onClickStep(Math.max(activeStep - 1, 0))
+  }
+
+  const onNext = (v: StepState) => {
+    history.current.push(state)
+    setState(v)
+    
+    if (v.type === StepType.validateData && 'isFromScratch' in v && v.isFromScratch) {
+      // If starting from scratch, jump directly to the validation step
+      const validationStepIndex = steps.indexOf('validationStep')
+      setActiveStep(validationStepIndex)
+    } else if (v.type !== StepType.selectSheet) {
+      setActiveStep(activeStep + 1)
+    }
+  }
+
+  return (
+    <>
+      <div className="hidden border-b bg-muted px-4 py-6 md:block">
+        <nav className="mx-auto flex items-center justify-center gap-4 lg:gap-24" aria-label="Steps">
+          {steps.map((key, index) => {
+            const isActive = index === activeStep
+            const isCompleted = index < activeStep
+            return (
+              <div key={key} className="flex items-center">
+                <button
+                  className={`group flex items-center ${isNavigationEnabled ? 'cursor-pointer' : 'cursor-default'}`}
+                  onClick={isNavigationEnabled ? () => onClickStep(index) : undefined}
+                  disabled={!isNavigationEnabled}
+                >
+                  <div className={`flex shrink-0 h-10 w-10 items-center justify-center rounded-full border-2 ${
+                    isActive 
+                      ? 'border-primary bg-primary text-primary-foreground'
+                      : isCompleted
+                      ? 'border-primary bg-primary text-primary-foreground'
+                      : 'border-muted-foreground/20 bg-background'
+                  }`}>
+                    {isCompleted ? (
+                      <CheckIcon color="text-primary-foreground" />
+                    ) : (
+                      <span className={`text-sm font-medium ${
+                        isActive ? 'text-primary-foreground' : 'text-muted-foreground'
+                      }`}>
+                        {index + 1}
+                      </span>
+                    )}
+                  </div>
+                  <span className={`ml-2 text-sm font-medium ${
+                    isActive ? 'text-foreground' : 'text-muted-foreground'
+                  }`}>
+                    {translations[key].title}
+                  </span>
+                </button>
+              </div>
+            )
+          })}
+        </nav>
+      </div>
+      <UploadFlow state={state} onNext={onNext} onBack={isNavigationEnabled ? onBack : undefined} />
+    </>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/steps/UploadFlow.tsx

@@ -0,0 +1,260 @@
+import { useCallback, useState } from "react"
+import type XLSX from "xlsx"
+import { UploadStep } from "./UploadStep/UploadStep"
+import { SelectHeaderStep } from "./SelectHeaderStep/SelectHeaderStep"
+import { SelectSheetStep } from "./SelectSheetStep/SelectSheetStep"
+import { mapWorkbook } from "../utils/mapWorkbook"
+import { ValidationStepNew } from "./ValidationStepNew"
+import { ImageUploadStep } from "./ImageUploadStep/ImageUploadStep"
+import { MatchColumnsStep, type GlobalSelections } from "./MatchColumnsStep/MatchColumnsStep"
+import { exceedsMaxRecords } from "../utils/exceedsMaxRecords"
+import { useRsi } from "../hooks/useRsi"
+import type { RawData, Data } from "../types"
+import { Progress } from "@/components/ui/progress"
+import { useToast } from "@/hooks/use-toast"
+import { addErrorsAndRunHooks } from "./ValidationStepNew/utils/dataMutations"
+
+export enum StepType {
+  upload = "upload",
+  selectSheet = "selectSheet",
+  selectHeader = "selectHeader",
+  matchColumns = "matchColumns",
+  validateData = "validateData",
+  imageUpload = "imageUpload",
+}
+
+export type StepState =
+  | {
+      type: StepType.upload
+    }
+  | {
+      type: StepType.selectSheet
+      workbook: XLSX.WorkBook
+    }
+  | {
+      type: StepType.selectHeader
+      data: RawData[]
+    }
+  | {
+      type: StepType.matchColumns
+      data: RawData[]
+      headerValues: RawData
+      globalSelections?: GlobalSelections
+    }
+  | {
+      type: StepType.validateData
+      data: any[]
+      globalSelections?: GlobalSelections
+      isFromScratch?: boolean
+    }
+  | {
+      type: StepType.imageUpload
+      data: any[]
+      file: File
+      globalSelections?: GlobalSelections
+    }
+
+interface Props {
+  state: StepState
+  onNext: (v: StepState) => void
+  onBack?: () => void
+}
+
+export const UploadFlow = ({ state, onNext, onBack }: Props) => {
+  const {
+    maxRecords,
+    translations,
+    uploadStepHook,
+    selectHeaderStepHook,
+    matchColumnsStepHook,
+    fields,
+    rowHook,
+    tableHook,
+    onSubmit  } = useRsi()
+  const [uploadedFile, setUploadedFile] = useState<File | null>(null)
+  const { toast } = useToast()
+  const errorToast = useCallback(
+    (description: string) => {
+      toast({
+        variant: "destructive",
+        title: translations.alerts.toast.error,
+        description,
+      })
+    },
+    [toast, translations],
+  )
+
+  // Keep track of global selections across steps
+  const [persistedGlobalSelections, setPersistedGlobalSelections] = useState<GlobalSelections | undefined>(
+    state.type === StepType.validateData || state.type === StepType.matchColumns 
+      ? state.globalSelections 
+      : undefined
+  )
+
+
+  switch (state.type) {
+    case StepType.upload:
+      return (
+        <UploadStep
+          onContinue={async (workbook, file) => {
+            setUploadedFile(file)
+            const isSingleSheet = workbook.SheetNames.length === 1
+            if (isSingleSheet) {
+              if (maxRecords && exceedsMaxRecords(workbook.Sheets[workbook.SheetNames[0]], maxRecords)) {
+                errorToast(translations.uploadStep.maxRecordsExceeded(maxRecords.toString()))
+                return
+              }
+              try {
+                const mappedWorkbook = await uploadStepHook(mapWorkbook(workbook))
+                onNext({
+                  type: StepType.selectHeader,
+                  data: mappedWorkbook,
+                })
+              } catch (e) {
+                errorToast((e as Error).message)
+              }
+            } else {
+              onNext({ type: StepType.selectSheet, workbook })
+            }
+          }}
+          setInitialState={(state) => {
+            // Ensure the state has the correct type
+            if (state.type === StepType.validateData) {
+              onNext({
+                type: StepType.validateData,
+                data: state.data,
+                isFromScratch: state.isFromScratch,
+                globalSelections: undefined
+              });
+            }
+          }}
+        />
+      )
+    case StepType.selectSheet:
+      return (
+        <SelectSheetStep
+          sheetNames={state.workbook.SheetNames}
+          onContinue={async (sheetName) => {
+            if (maxRecords && exceedsMaxRecords(state.workbook.Sheets[sheetName], maxRecords)) {
+              errorToast(translations.uploadStep.maxRecordsExceeded(maxRecords.toString()))
+              return
+            }
+            try {
+              const mappedWorkbook = await uploadStepHook(mapWorkbook(state.workbook, sheetName))
+              onNext({
+                type: StepType.selectHeader,
+                data: mappedWorkbook,
+              })
+            } catch (e) {
+              errorToast((e as Error).message)
+            }
+          }}
+          onBack={onBack}
+        />
+      )
+    case StepType.selectHeader:
+      return (
+        <SelectHeaderStep
+          data={state.data}
+          onContinue={async (...args) => {
+            try {
+              const { data, headerValues } = await selectHeaderStepHook(...args)
+              onNext({
+                type: StepType.matchColumns,
+                data,
+                headerValues,
+                globalSelections: persistedGlobalSelections,
+              })
+            } catch (e) {
+              errorToast((e as Error).message)
+            }
+          }}
+          onBack={onBack}
+        />
+      )
+    case StepType.matchColumns:
+      return (
+        <MatchColumnsStep
+          data={state.data}
+          headerValues={state.headerValues}
+          initialGlobalSelections={persistedGlobalSelections}
+          onContinue={async (values, rawData, columns, globalSelections) => {
+            try {
+              const data = await matchColumnsStepHook(values, rawData, columns)
+              const dataWithMeta = await addErrorsAndRunHooks(data, fields, rowHook, tableHook)
+              
+              // Apply global selections to each row of data if they exist
+              const dataWithGlobalSelections = globalSelections 
+                ? dataWithMeta.map((row: Data<string> & { __errors?: any; __index?: string }) => {
+                    const newRow = { ...row };
+                    if (globalSelections.supplier) newRow.supplier = globalSelections.supplier;
+                    if (globalSelections.company) newRow.company = globalSelections.company;
+                    if (globalSelections.line) newRow.line = globalSelections.line;
+                    if (globalSelections.subline) newRow.subline = globalSelections.subline;
+                    return newRow;
+                  })
+                : dataWithMeta;
+              
+              setPersistedGlobalSelections(globalSelections)
+              onNext({
+                type: StepType.validateData,
+                data: dataWithGlobalSelections,
+                globalSelections,
+              })
+            } catch (e) {
+              errorToast((e as Error).message)
+            }
+          }}
+          onBack={onBack}
+        />
+      )
+    case StepType.validateData:
+      // Always use the new ValidationStepNew component
+      return (
+        <ValidationStepNew
+          initialData={state.data} 
+          file={uploadedFile || new File([], "empty.xlsx")} 
+          onBack={() => {
+            // If we started from scratch, we need to go back to the upload step
+            if (state.isFromScratch) {
+              onNext({
+                type: StepType.upload
+              });
+            } else if (onBack) {
+              // Use the provided onBack function
+              onBack();
+            }
+          }}
+          onNext={(validatedData) => {
+            // Go to image upload step with the validated data
+            onNext({
+              type: StepType.imageUpload,
+              data: validatedData,
+              file: uploadedFile || new File([], "empty.xlsx"),
+              globalSelections: state.globalSelections
+            });
+          }}
+          isFromScratch={state.isFromScratch}
+        />
+      )
+    case StepType.imageUpload:
+      return (
+        <ImageUploadStep
+          data={state.data}
+          file={state.file}
+          onBack={onBack}
+          onSubmit={(data, file) => {
+            // Create a Result object from the array data
+            const result = {
+              validData: data as Data<string>[],
+              invalidData: [] as Data<string>[],
+              all: data as Data<string>[]
+            };
+            onSubmit(result, file);
+          }}
+        />
+      )
+    default:
+      return <Progress value={33} className="w-full" />
+  }
+}

inventory/src/lib/react-spreadsheet-import/src/steps/UploadStep/UploadStep.tsx

@@ -0,0 +1,61 @@
+import type XLSX from "xlsx"
+import { useCallback, useState } from "react"
+import { useRsi } from "../../hooks/useRsi"
+import { DropZone } from "./components/DropZone"
+import { StepType } from "../UploadFlow"
+import { Button } from "@/components/ui/button"
+import { Separator } from "@/components/ui/separator"
+
+type UploadProps = {
+  onContinue: (data: XLSX.WorkBook, file: File) => Promise<void>
+  setInitialState?: (state: { type: StepType; data: any[]; isFromScratch?: boolean }) => void
+}
+
+export const UploadStep = ({ onContinue, setInitialState }: UploadProps) => {
+  const [isLoading, setIsLoading] = useState(false)
+  const { translations } = useRsi()
+  
+  const handleOnContinue = useCallback(
+    async (data: XLSX.WorkBook, file: File) => {
+      setIsLoading(true)
+      await onContinue(data, file)
+      setIsLoading(false)
+    },
+    [onContinue],
+  )
+  
+  const handleStartFromScratch = useCallback(() => {
+    if (setInitialState) {
+      setInitialState({ type: StepType.validateData, data: [{}], isFromScratch: true })
+    }
+  }, [setInitialState])
+  
+  return (
+    <div className="p-8">
+      <h2 className="text-3xl font-semibold mb-8 text-left">{translations.uploadStep.title}</h2>
+      
+      <div className="max-w-xl mx-auto w-full space-y-8">
+        <div className="rounded-lg p-6 flex flex-col items-center">
+          <DropZone onContinue={handleOnContinue} isLoading={isLoading} />
+        </div>
+        
+        <div className="flex items-center justify-center">
+          <Separator className="w-24" />
+          <span className="px-3 text-muted-foreground text-sm font-medium">OR</span>
+          <Separator className="w-24" />
+        </div>
+        
+        <div className="flex justify-center">
+          <Button 
+            onClick={handleStartFromScratch}
+            variant="outline"
+            className="min-w-[200px]"
+            disabled={!setInitialState}
+          >
+            Start from scratch
+          </Button>
+        </div>
+      </div>
+    </div>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/steps/UploadStep/components/DropZone.tsx

@@ -0,0 +1,85 @@
+import { useDropzone } from "react-dropzone"
+import * as XLSX from "xlsx"
+import { useState } from "react"
+import { useRsi } from "../../../hooks/useRsi"
+import { readFileAsync } from "../utils/readFilesAsync"
+import { Button } from "@/components/ui/button"
+import { useToast } from "@/hooks/use-toast"
+import { cn } from "@/lib/utils"
+
+type DropZoneProps = {
+  onContinue: (data: XLSX.WorkBook, file: File) => void
+  isLoading: boolean
+}
+
+export const DropZone = ({ onContinue, isLoading }: DropZoneProps) => {
+  const { translations, maxFileSize, dateFormat, parseRaw } = useRsi()
+  const { toast } = useToast()
+  const [loading, setLoading] = useState(false)
+  const { getRootProps, getInputProps, isDragActive, open } = useDropzone({
+    noClick: true,
+    noKeyboard: true,
+    maxFiles: 1,
+    maxSize: maxFileSize,
+    accept: {
+      "application/vnd.ms-excel": [".xls"],
+      "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": [".xlsx"],
+      "text/csv": [".csv"],
+    },
+    onDropRejected: (fileRejections) => {
+      setLoading(false)
+      fileRejections.forEach((fileRejection) => {
+        toast({
+          variant: "destructive",
+          title: `${fileRejection.file.name} ${translations.uploadStep.dropzone.errorToastDescription}`,
+          description: fileRejection.errors[0].message,
+        })
+      })
+    },
+    onDropAccepted: async ([file]) => {
+      setLoading(true)
+      const arrayBuffer = await readFileAsync(file)
+      const workbook = XLSX.read(arrayBuffer, {
+        cellDates: true,
+        dateNF: dateFormat,
+        raw: parseRaw,
+        dense: true,
+        type: 'array',
+        codepage: 65001, // UTF-8
+        WTF: false // Don't throw on errors
+      })
+      setLoading(false)
+      onContinue(workbook, file)
+    },
+  })
+
+  return (
+    <div
+      {...getRootProps()}
+      className={cn(
+        "flex h-full w-full flex-1 flex-col items-center justify-center rounded-lg border-2 border-dashed border-secondary-foreground/30 bg-muted/90 p-12",
+        isDragActive && "border-primary bg-muted"
+      )}
+    >
+      <input {...getInputProps()} data-testid="rsi-dropzone" />
+      {isDragActive ? (
+        <p className="text-lg text-muted-foreground mb-1 py-6">
+          {translations.uploadStep.dropzone.activeDropzoneTitle}
+        </p>
+      ) : loading || isLoading ? (
+        <p className="text-lg text-muted-foreground">
+          {translations.uploadStep.dropzone.loadingTitle}
+        </p>
+      ) : (
+        <>
+          <p className="mb-4 text-lg text-muted-foreground">
+            {translations.uploadStep.dropzone.title}
+          </p>
+          <Button onClick={open} variant="default">
+            {translations.uploadStep.dropzone.buttonTitle}
+          </Button>
+        </>
+      )}
+    </div>
+  )
+}

inventory/src/lib/react-spreadsheet-import/src/steps/UploadStep/components/columns.tsx

@@ -0,0 +1,44 @@
+import type { Column } from "react-data-grid"
+import type { Fields } from "../../../types"
+import { CgInfo } from "react-icons/cg"
+import {
+  Tooltip,
+  TooltipContent,
+  TooltipProvider,
+  TooltipTrigger,
+} from "@/components/ui/tooltip"
+
+export const generateColumns = <T extends string>(fields: Fields<T>) =>
+  fields.map(
+    (column): Column<any> => ({
+      key: column.key,
+      name: column.label,
+      minWidth: 150,
+      headerRenderer: () => (
+        <div className="flex items-center gap-1 relative">
+          <div className="flex-1 overflow-hidden text-ellipsis">
+            {column.label}
+          </div>
+          {column.description && (
+            <TooltipProvider>
+              <Tooltip>
+                <TooltipTrigger asChild>
+                  <div className="flex-none">
+                    <CgInfo className="h-4 w-4" />
+                  </div>
+                </TooltipTrigger>
+                <TooltipContent>
+                  {column.description}
+                </TooltipContent>
+              </Tooltip>
+            </TooltipProvider>
+          )}
+        </div>
+      ),
+      formatter: ({ row }) => (
+        <div className="min-w-full min-h-full overflow-hidden text-ellipsis">
+          {row[column.key]}
+        </div>
+      ),
+    }),
+  )

inventory/src/lib/react-spreadsheet-import/src/steps/UploadStep/utils/readFilesAsync.ts

@@ -0,0 +1,13 @@
+export const readFileAsync = (file: File) => {
+  return new Promise((resolve, reject) => {
+    const reader = new FileReader()
+
+    reader.onload = () => {
+      resolve(reader.result)
+    }
+
+    reader.onerror = reject
+
+    reader.readAsArrayBuffer(file)
+  })
+}

inventory/src/lib/react-spreadsheet-import/src/steps/ValidationStepNew/README.md

@@ -0,0 +1,58 @@
+# ValidationStepNew Component
+
+This is a refactored version of the original ValidationStep component with improved architecture, performance, and maintainability.
+
+## Overview
+
+The ValidationStepNew component is designed to replace the original ValidationStep component in the React Spreadsheet Import library. It provides the same functionality but with a more modular and maintainable codebase.
+
+## Features
+
+- Field-level validation (required, regex, unique)
+- Row-level validation (supplier, company fields)
+- UPC validation with API integration
+- Template management (saving, loading, applying)
+- Filtering and sorting capabilities
+- Error display and management
+- Special field handling (input, multi-input, select, checkbox)
+
+## Usage
+
+To use the new ValidationStepNew component, select the "Use new validation component" checkbox in the MatchColumnsStep. This will route you to the new implementation instead of the original one.
+
+## Architecture
+
+The component is structured as follows:
+
+- **ValidationContainer**: Main container component that coordinates all subcomponents
+- **ValidationTable**: Handles data display, filtering, and column configuration
+- **ValidationCell**: Cell-level component with specialized rendering based on field type
+- **ValidationToolbar**: Top toolbar with actions and statistics
+- **ValidationSidebar**: Contains filters, actions, and other UI controls
+
+## State Management
+
+State is managed through custom hooks:
+
+- **useValidationState**: Main state management hook
+- **useValidation**: Validation logic
+- **useTemplates**: Template management
+- **useFilters**: Filtering logic
+- **useUpcValidation**: UPC validation
+
+## Development
+
+This component is still under development. The goal is to eventually replace the original ValidationStep component completely once all functionality is implemented and tested.
+
+## Known Issues
+
+- Some TypeScript errors in the UploadFlow component when integrating with the new component
+- Not all features from the original component are fully implemented yet
+
+## Roadmap
+
+1. Complete implementation of all features from the original component
+2. Add comprehensive tests
+3. Improve performance with virtualization for large datasets
+4. Add more customization options
+5. Replace the original component completely