Add AI name/description validation to product editor

.claude/CLAUDE.md

@@ -0,0 +1,172 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+This is a full-stack inventory management system with a React + TypeScript frontend and Node.js/Express backend using PostgreSQL. The system includes product management, analytics, forecasting, purchase orders, and a comprehensive dashboard for business metrics.
+
+**Monorepo Structure:**
+- `inventory/` - Vite-based React frontend with TypeScript
+- `inventory-server/` - Express backend API server
+- Root `package.json` contains shared dependencies
+
+## Development Commands
+
+### Frontend (inventory/)
+```bash
+cd inventory
+npm run dev        # Start dev server on port 5175
+npm run build      # Build for production (outputs to build/ then copies to ../inventory-server/frontend/build)
+npm run lint       # Run ESLint
+npm run preview    # Preview production build
+```
+
+### Backend (inventory-server/)
+```bash
+cd inventory-server
+npm run dev        # Start with nodemon (auto-reload)
+npm start          # Start server (production)
+npm run prod       # Start with PM2 for production
+npm run prod:stop  # Stop PM2 instance
+npm run prod:restart  # Restart PM2 instance
+npm run prod:logs  # View PM2 logs
+npm run setup      # Create required directories (logs, uploads)
+```
+
+## Architecture
+
+### Frontend Architecture
+
+**Router Structure:** React Router with lazy loading for code splitting:
+- Main chunks: Core inventory, Dashboard, Product Import, Chat Archive
+- Authentication flow uses `RequireAuth` and `Protected` components with permission-based access
+- All routes except `/login` and `/small` require authentication
+
+**Key Directories:**
+- `src/pages/` - Top-level page components (Overview, Products, Analytics, Dashboard, etc.)
+- `src/components/` - Organized by feature (dashboard/, products/, analytics/, etc.)
+- `src/components/ui/` - shadcn/ui components
+- `src/types/` - TypeScript type definitions
+- `src/contexts/` - React contexts (AuthContext, DashboardScrollContext)
+- `src/hooks/` - Custom React hooks (use-toast, useDebounce, use-mobile)
+- `src/utils/` - Utility functions (emojiUtils, productUtils, naturalLanguagePeriod)
+- `src/services/` - API service layer
+- `src/config/` - Configuration files
+
+**State Management:**
+- React Context for auth and global state
+- @tanstack/react-query for server state management
+- zustand for client state management
+- Local storage for auth tokens, session storage for login state
+
+**Key Dependencies:**
+- UI: Radix UI primitives, shadcn/ui, Tailwind CSS, Framer Motion
+- Data: @tanstack/react-table, react-data-grid, @tanstack/react-virtual
+- Forms: react-hook-form, zod
+- Charts: recharts, chart.js, react-chartjs-2
+- File handling: xlsx for Excel export, react-dropzone for uploads
+- Other: axios for HTTP, date-fns/luxon for dates
+
+**Path Alias:** `@/` maps to `./src/`
+
+### Backend Architecture
+
+**Entry Point:** `inventory-server/src/server.js`
+
+**Key Directories:**
+- `src/routes/` - Express route handlers (products, dashboard, analytics, import, etc.)
+- `src/middleware/` - Express middleware (CORS, auth, etc.)
+- `src/utils/` - Utility functions (database connection, API helpers)
+- `src/types/` - Type definitions (e.g., status-codes)
+
+**Database:**
+- PostgreSQL with connection pooling (pg library)
+- Pool initialized in `utils/db.js` via `initPool()`
+- Pool attached to `app.locals.pool` for route access
+- Environment variables loaded from `/var/www/html/inventory/.env` (production path)
+
+**API Routes:** All prefixed with `/api/`
+- `/api/products` - Product CRUD operations
+- `/api/dashboard` - Dashboard metrics and data
+- `/api/analytics` - Analytics and reporting
+- `/api/orders` - Order management
+- `/api/purchase-orders` - Purchase order management
+- `/api/csv` - CSV import/export (data management)
+- `/api/import` - Product import workflows
+- `/api/config` - Configuration management
+- `/api/metrics` - System metrics
+- `/api/ai-validation` - AI-powered validation
+- `/api/ai-prompts` - AI prompt management
+- `/api/templates` - Template management
+- `/api/reusable-images` - Image management
+- `/api/categoriesAggregate`, `/api/vendorsAggregate`, `/api/brandsAggregate` - Aggregate data endpoints
+
+**Authentication:**
+- External auth service at `/auth-inv` endpoint
+- Token-based authentication (Bearer tokens)
+- Frontend stores tokens in localStorage
+- Protected routes verify tokens via auth service `/me` endpoint
+
+**File Uploads:**
+- Multer middleware for file handling
+- Uploads directory: `inventory-server/uploads/`
+
+### Development Proxy Setup
+
+The Vite dev server (port 5175) proxies API requests to `https://inventory.kent.pw`:
+- `/api/*` → production API
+- `/auth-inv/*` → authentication service
+- `/chat-api/*` → chat service
+- `/uploads/*` → uploaded files
+- Various third-party services (Aircall, Klaviyo, Meta, Gorgias, Typeform, ACOT, Clarity)
+
+### Build Process
+
+When building the frontend:
+1. TypeScript compilation (`tsc -b`)
+2. Vite build (outputs to `inventory/build/`)
+3. Custom Vite plugin copies build to `inventory-server/frontend/build/`
+4. Manual chunks for vendor splitting (react-vendor, ui-vendor, query-vendor)
+
+## Testing
+
+Run tests for individual components or features:
+```bash
+# No test suite currently configured
+# Tests would typically use Jest or Vitest with React Testing Library
+```
+
+## Common Development Workflows
+
+### Adding a New Page
+1. Create page component in `inventory/src/pages/YourPage.tsx`
+2. Add lazy import in `inventory/src/App.tsx`
+3. Add route with `<Protected>` wrapper and permission check
+4. Add corresponding backend route in `inventory-server/src/routes/`
+5. Update permission system if needed
+
+### Adding a New API Endpoint
+1. Create or update route file in `inventory-server/src/routes/`
+2. Use `executeQuery()` helper for database queries
+3. Register router in `inventory-server/src/server.js`
+4. Frontend can access at `/api/{route-name}`
+
+### Working with Database
+- Use parameterized queries: `executeQuery(sql, [param1, param2])`
+- Pool is accessed via `db.getPool()` or `app.locals.pool`
+- Connection helper: `db.getConnection()` returns a client for transactions
+
+### Permissions System
+- User permissions stored in `user.permissions` array (permission codes)
+- Check permissions in `<Protected page="permission_code">` component
+- Admin users (`is_admin: true`) have access to all pages
+
+## Important Notes
+
+- Environment variables must be configured in `/var/www/html/inventory/.env` for production
+- The frontend expects the backend at `/api` (proxied in dev, served together in production)
+- PM2 is used for production process management
+- Database uses PostgreSQL with SSL support (configurable via `DB_SSL` env var)
+- File uploads stored in `inventory-server/uploads/` directory
+- Build artifacts in `inventory/build/` are copied to `inventory-server/frontend/build/`

.gitignore

@@ -67,4 +67,21 @@ inventory-server/scripts/.fuse_hidden00000fa20000000a
 
 .VSCodeCounter/
 .VSCodeCounter/*
-.VSCodeCounter/**/*
+.VSCodeCounter/**/*
+
+*/chat/db-convert/db/*
+*/chat/db-convert/mongo_converter_env/*
+
+# Ignore compiled Vite config to avoid duplication
+vite.config.js
+inventory-server/inventory_backup.sql
+chat-files.tar.gz
+chat-migration*/
+**/chat-migration*/
+chat-migration*/**
+**/chat-migration*/**
+
+venv/
+venv/**
+**/venv/*
+**/venv/**

CLAUDE.md

@@ -0,0 +1,4 @@
+* Avoid using glob tool for search as it may not work properly on this codebase. Search using bash instead.
+* If you use the task tool to have an agent investigate something, make sure to let it know to avoid using glob
+* Prefer solving tasks in a single session. Only spawn subagents for genuinely independent workstreams.
+* The postgres/query tool is not working and not connected to the current version of the database. If you need to query the database for any reason you can use "ssh netcup" and use psql on the server with inventory_readonly 6D3GUkxuFgi2UghwgnUd

PRODUCT_IMPORT_ENHANCEMENTS.md

@@ -0,0 +1,375 @@
+# Product Import Module - Enhancement & Issues Outline
+
+This document outlines the investigation and implementation requirements for each requested enhancement to the product import module.
+
+---
+
+## 1. UPC Import - Strip Quotes and Spaces ✅ IMPLEMENTED
+
+**Issue:** When importing UPCs, strip `'`, `"` characters and any spaces, leaving only numbers.
+
+**Implementation (Completed):**
+- Modified `normalizeUpcValue()` in [Import.tsx:661-667](inventory/src/pages/Import.tsx#L661-L667)
+- Strips single quotes, double quotes, smart quotes (`'"`), and whitespace before processing
+- Then handles scientific notation and extracts only digits
+
+**Files Modified:**
+- `inventory/src/pages/Import.tsx` - `normalizeUpcValue()` function
+
+---
+
+## 2. AI Context Columns in Validation Payloads ✅ IMPLEMENTED
+
+**Issue:** The match columns step has a setting to use a field only for AI context (`isAiSupplemental`). Update AI description validation to include any columns selected with this option in the payload. Also include in sanity check payload. Not needed for names.
+
+**Current Implementation:**
+- AI Supplemental toggle: [MatchColumnsStep.tsx:102-118](inventory/src/components/product-import/steps/MatchColumnsStep/MatchColumnsStep.tsx#L102-L118)
+- AI supplemental data stored in `__aiSupplemental` field on each row
+- Description payload builder: [inlineAiPayload.ts:183-195](inventory/src/components/product-import/steps/ValidationStep/utils/inlineAiPayload.ts#L183-L195)
+
+**Implementation:**
+1. **Update `buildDescriptionValidationPayload()` in `inlineAiPayload.ts`** to include AI supplemental data:
+   ```typescript
+   export const buildDescriptionValidationPayload = (
+     row: Data<string>,
+     fieldOptions: FieldOptionsMap,
+     productLinesCache: Map<string, SelectOption[]>,
+     sublinesCache: Map<string, SelectOption[]>
+   ) => {
+     const payload: Record<string, unknown> = {
+       name: row.name,
+       description: row.description,
+       company_name: getFieldOptionLabel(row.company, fieldOptions, 'company'),
+       company_id: row.company,
+       categories: getFieldOptionLabel(row.category, fieldOptions, 'category'),
+     };
+
+     // Add AI supplemental context if present
+     if (row.__aiSupplemental && typeof row.__aiSupplemental === 'object') {
+       payload.additional_context = row.__aiSupplemental;
+     }
+
+     return payload;
+   };
+   ```
+
+2. **Update sanity check payload** - Locate sanity check submission logic and include `__aiSupplemental` data
+
+3. **Verify `__aiSupplemental` is properly populated** from MatchColumnsStep when columns are marked as AI context only
+
+**Files to Modify:**
+- `inventory/src/components/product-import/steps/ValidationStep/utils/inlineAiPayload.ts`
+- Backend sanity check endpoint (if separate from description validation)
+- Verify data flow in `MatchColumnsStep.tsx` → `ValidationStep`
+
+---
+
+## 3. Fresh Taxonomy Data Per Session ✅ IMPLEMENTED
+
+**Issue:** Ensure taxonomy data is brought in fresh with each session - cache should be invalidated if we exit the import flow and start again.
+
+**Current Implementation:**
+- Field options cached 5 minutes: [ValidationStep/index.tsx:128-133](inventory/src/components/product-import/steps/ValidationStep/index.tsx#L128-L133)
+- Product lines cache: `productLinesCache` in Zustand store
+- Sublines cache: `sublinesCache` in Zustand store
+- Caches set to 10-minute stale time
+
+**Implementation:**
+1. **Add cache invalidation on import flow mount/unmount** in `UploadFlow.tsx`:
+   ```typescript
+   useEffect(() => {
+     // On mount - invalidate import-related query cache
+     queryClient.invalidateQueries({ queryKey: ['import-field-options'] });
+
+     return () => {
+       // On unmount - clear caches
+       queryClient.removeQueries({ queryKey: ['import-field-options'] });
+       queryClient.removeQueries({ queryKey: ['product-lines'] });
+       queryClient.removeQueries({ queryKey: ['sublines'] });
+     };
+   }, []);
+   ```
+
+2. **Clear Zustand store caches** when exiting import flow:
+   - Add action to `validationStore.ts` to clear `productLinesCache` and `sublinesCache`
+   - Call this action on unmount of `UploadFlow` or when navigating away
+
+3. **Consider adding a `sessionId`** that changes on each import flow start, used as part of cache keys
+
+**Files to Modify:**
+- `inventory/src/components/product-import/steps/UploadFlow.tsx` - Add cleanup effect
+- `inventory/src/components/product-import/steps/ValidationStep/store/validationStore.ts` - Add cache clear action
+- Potentially `inventory/src/components/product-import/steps/ValidationStep/index.tsx` - Query key updates
+
+---
+
+## 4. Save Template from Confirmation Page ✅ IMPLEMENTED
+
+**Issue:** Add option to save rows of submitted data as a new template on the confirmation page after completing the import flow. Verify this works with new validation step changes.
+
+**Current Implementation:**
+- **Import Results section already exists** inline in [Import.tsx:968-1150](inventory/src/pages/Import.tsx#L968-L1150)
+  - Shows created products (lines 1021-1097) with image, name, UPC, item number
+  - Shows errored products (lines 1100-1138) with error details
+  - "Fix products with errors" button resumes validation flow for failed items
+- Template saving logic in ValidationStep: [useTemplateManagement.ts:204-266](inventory/src/components/product-import/steps/ValidationStep/hooks/useTemplateManagement.ts#L204-L266)
+- Saves via `POST /api/templates`
+- `importOutcome.submittedProducts` contains the full product data for each row
+
+**Implementation:**
+1. **Add "Save as Template" button** to each created product row in the results section (around line 1087-1092 in Import.tsx):
+   ```typescript
+   // Add button after the item number display
+   <Button
+     variant="ghost"
+     size="sm"
+     onClick={() => handleSaveAsTemplate(index)}
+   >
+     <BookmarkPlus className="h-4 w-4" />
+   </Button>
+   ```
+
+2. **Add state and dialog** for template saving in Import.tsx:
+   ```typescript
+   const [templateSaveDialogOpen, setTemplateSaveDialogOpen] = useState(false);
+   const [selectedProductForTemplate, setSelectedProductForTemplate] = useState<NormalizedProduct | null>(null);
+   ```
+
+3. **Extract/reuse template save logic** from `useTemplateManagement.ts`:
+   - The `saveNewTemplate()` function (lines 204-266) can be extracted into a shared utility
+   - Or create a `SaveTemplateDialog` component that can be used in both places
+   - Key fields needed: `company` (for template name), `product_type`, and all product field values
+
+4. **Data mapping consideration:**
+   - `importOutcome.submittedProducts` uses `NormalizedProduct` type
+   - Templates expect raw field values - may need to map back from normalized format
+   - Exclude metadata fields: `['id', '__index', '__meta', '__template', '__original', '__corrected', '__changes', '__aiSupplemental']`
+
+**Files to Modify:**
+- `inventory/src/pages/Import.tsx` - Add save template button, state, and dialog
+- Consider creating `inventory/src/components/product-import/SaveTemplateDialog.tsx` for reusability
+- Potentially extract core save logic from `useTemplateManagement.ts` into shared utility
+
+---
+
+## 5. Sheet Preview on Select Sheet Step ✅ IMPLEMENTED
+
+**Issue:** On the select sheet step, show a preview of the first 10 lines or so of each sheet underneath the options.
+
+**Implementation (Completed):**
+- Added `workbook` prop to `SelectSheetStep` component
+- Added `sheetPreviews` memoized computation using `XLSXLib.utils.sheet_to_json()`
+- Shows first 10 rows, 8 columns max per sheet
+- Added `truncateCell()` helper to limit cell content to 30 characters with ellipsis
+- Each sheet option is now a clickable card with:
+  - Radio button and sheet name
+  - Row count indicator
+  - Scrollable preview table with horizontal scroll
+  - Selected state highlighted with primary border
+- Updated `UploadFlow.tsx` to pass workbook prop
+
+**Files Modified:**
+- `inventory/src/components/product-import/steps/SelectSheetStep/SelectSheetStep.tsx`
+- `inventory/src/components/product-import/steps/UploadFlow.tsx`
+
+---
+
+## 6. Empty Row Removal ✅ IMPLEMENTED
+
+**Issue:** When importing a sheet, automatically remove completely empty rows.
+
+**Current Implementation:**
+- Empty columns are filtered: [MatchColumnsStep.tsx:616-634](inventory/src/components/product-import/steps/MatchColumnsStep/MatchColumnsStep.tsx#L616-L634)
+- A "Remove empty/duplicates" button exists that removes empty rows, single-value rows, AND duplicates
+- The automatic removal should ONLY remove completely empty rows, not duplicates or single-value rows
+
+**Implementation (Completed):**
+- Added `isRowCompletelyEmpty()` helper function to [SelectHeaderStep.tsx](inventory/src/components/product-import/steps/SelectHeaderStep/SelectHeaderStep.tsx)
+- Added `useMemo` to filter empty rows on initial data load
+- Uses `Object.values(row)` to check all cell values (matches existing button logic)
+- Only removes rows where ALL values are undefined, null, or whitespace-only strings
+- Manual "Remove Empty/Duplicates" button still available for additional cleanup (duplicates, single-value rows)
+
+**Files Modified:**
+- `inventory/src/components/product-import/steps/SelectHeaderStep/SelectHeaderStep.tsx`
+
+---
+
+## 7. Unit Conversion for Weight/Dimensions ✅ IMPLEMENTED
+
+**Issue:** Add unit conversion feature for weight and dimensions columns - similar to calculator button on cost/msrp, add button that opens popover with options to convert grams → oz, lbs → oz for the whole column at once.
+
+**Current Implementation:**
+- Calculator button on price columns: [ValidationTable.tsx:1491-1627](inventory/src/components/product-import/steps/ValidationStep/components/ValidationTable.tsx#L1491-L1627)
+- `PriceColumnHeader` component shows calculator icon on hover
+- Weight field defined in config with validation
+
+**Implementation:**
+1. **Create `UnitConversionColumnHeader` component** (similar to `PriceColumnHeader`):
+   ```typescript
+   const UnitConversionColumnHeader = ({ field, table }) => {
+     const [showPopover, setShowPopover] = useState(false);
+
+     const conversions = {
+       weight: [
+         { label: 'Grams → Ounces', factor: 0.035274 },
+         { label: 'Pounds → Ounces', factor: 16 },
+         { label: 'Kilograms → Ounces', factor: 35.274 },
+       ],
+       dimensions: [
+         { label: 'Centimeters → Inches', factor: 0.393701 },
+         { label: 'Millimeters → Inches', factor: 0.0393701 },
+       ]
+     };
+
+     const applyConversion = (factor: number) => {
+       // Batch update all cells in column
+       table.rows.forEach((row, index) => {
+         const currentValue = parseFloat(row[field.key]);
+         if (!isNaN(currentValue)) {
+           updateCell(index, field.key, (currentValue * factor).toFixed(2));
+         }
+       });
+     };
+
+     return (
+       <Popover open={showPopover} onOpenChange={setShowPopover}>
+         <PopoverTrigger>
+           <Scale className="h-4 w-4" /> {/* or similar icon */}
+         </PopoverTrigger>
+         <PopoverContent>
+           {conversions[fieldType].map(conv => (
+             <Button key={conv.label} onClick={() => applyConversion(conv.factor)}>
+               {conv.label}
+             </Button>
+           ))}
+         </PopoverContent>
+       </Popover>
+     );
+   };
+   ```
+
+2. **Identify weight/dimension fields** in config:
+   - `weight_oz`, `length_in`, `width_in`, `height_in` (check actual field keys)
+
+3. **Add to column header render logic** in ValidationTable
+
+**Files to Modify:**
+- `inventory/src/components/product-import/steps/ValidationStep/components/ValidationTable.tsx`
+- Potentially create new component file for `UnitConversionColumnHeader`
+- Update column header rendering to use new component for weight/dimension fields
+
+---
+
+## 8. Expanded MSRP Auto-Fill from Cost ✅ IMPLEMENTED
+
+**Issue:** Expand auto-fill functionality for MSRP from cost - open small popover with options for 2x, 2.1x, 2.2x, 2.3x, 2.4x, 2.5x multipliers, plus checkbox to round up to nearest 9.
+
+**Current Implementation:**
+- Calculator on MSRP column: [ValidationTable.tsx:1540-1584](inventory/src/components/product-import/steps/ValidationStep/components/ValidationTable.tsx#L1540-L1584)
+- Currently only does `Cost × 2` then subtracts 0.01 if whole number
+
+**Implementation:**
+1. **Replace simple click with popover** in `PriceColumnHeader`:
+   ```typescript
+   const [selectedMultiplier, setSelectedMultiplier] = useState(2.0);
+   const [roundToNine, setRoundToNine] = useState(false);
+   const multipliers = [2.0, 2.1, 2.2, 2.3, 2.4, 2.5];
+
+   const roundUpToNine = (value: number): number => {
+     // 1.41 → 1.49, 2.78 → 2.79, 12.32 → 12.39
+     const wholePart = Math.floor(value);
+     const decimal = value - wholePart;
+     if (decimal <= 0.09) return wholePart + 0.09;
+     if (decimal <= 0.19) return wholePart + 0.19;
+     // ... continue pattern, or:
+     const lastDigit = Math.floor(decimal * 10);
+     return wholePart + (lastDigit / 10) + 0.09;
+   };
+
+   const calculateMsrp = (cost: number): number => {
+     let result = cost * selectedMultiplier;
+     if (roundToNine) {
+       result = roundUpToNine(result);
+     }
+     return result;
+   };
+   ```
+
+2. **Create popover UI**:
+   ```tsx
+   <Popover>
+     <PopoverTrigger><Calculator className="h-4 w-4" /></PopoverTrigger>
+     <PopoverContent className="w-48">
+       <div className="space-y-2">
+         <Label>Multiplier</Label>
+         <div className="grid grid-cols-3 gap-1">
+           {multipliers.map(m => (
+             <Button
+               key={m}
+               variant={selectedMultiplier === m ? 'default' : 'outline'}
+               size="sm"
+               onClick={() => setSelectedMultiplier(m)}
+             >
+               {m}x
+             </Button>
+           ))}
+         </div>
+         <div className="flex items-center gap-2">
+           <Checkbox checked={roundToNine} onCheckedChange={setRoundToNine} />
+           <Label>Round to .X9</Label>
+         </div>
+         <Button onClick={applyCalculation} className="w-full">
+           Apply
+         </Button>
+       </div>
+     </PopoverContent>
+   </Popover>
+   ```
+
+**Files to Modify:**
+- `inventory/src/components/product-import/steps/ValidationStep/components/ValidationTable.tsx` - `PriceColumnHeader` component
+
+---
+
+## 9. Debug Mode - Skip API Submission ✅ IMPLEMENTED
+
+**Issue:** Add a third switch in the footer of image upload step (visible only to users with `admin:debug` permission) that will not submit data to any API, only complete the process and show results page as if it had worked.
+
+**Implementation (Completed):**
+- Added `skipApiSubmission` state to `ImageUploadStep.tsx`
+- Added amber-colored "Skip API (Debug)" switch (visible only with `admin:debug` permission)
+- When skip is active, "Use Test API" and "Use Test Database" switches are hidden
+- Added `skipApiSubmission?: boolean` to `SubmitOptions` type in `types.ts`
+- In `Import.tsx`, when `skipApiSubmission` is true:
+  - Skips the actual API call entirely
+  - Generates mock success response with mock PIDs
+  - Shows `[DEBUG]` prefix in toast and result message
+  - Displays results page as if submission succeeded
+
+**Files Modified:**
+- `inventory/src/components/product-import/types.ts` - Added `skipApiSubmission` to `SubmitOptions`
+- `inventory/src/components/product-import/steps/ImageUploadStep/ImageUploadStep.tsx` - Added switch UI
+- `inventory/src/pages/Import.tsx` - Added skip logic in `handleData()`
+
+---
+
+## Summary
+
+| # | Enhancement | Complexity | Status |
+|---|-------------|------------|--------|
+| 1 | Strip UPC quotes/spaces | Low | ✅ Implemented |
+| 2 | AI context in validation | Medium | ✅ Implemented |
+| 3 | Fresh taxonomy per session | Medium | ✅ Implemented |
+| 4 | Save template from confirmation | Medium-High | ✅ Implemented |
+| 5 | Sheet preview | Low-Medium | ✅ Implemented |
+| 6 | Remove empty rows | Low | ✅ Implemented |
+| 7 | Unit conversion | Medium | ✅ Implemented |
+| 8 | MSRP multiplier options | Medium | ✅ Implemented |
+| 9 | Debug skip API | Low-Medium | ✅ Implemented |
+
+**Implemented:** 9 of 9 items - All enhancements complete!
+
+---
+
+*Document generated: 2026-01-25*

docs/METRICS_AUDIT.md

@@ -0,0 +1,346 @@
+# Metrics Calculation Pipeline Audit
+
+**Date:** 2026-02-07
+**Scope:** All 6 SQL calculation scripts, custom DB functions, import pipeline, and live data verification
+
+## Overview
+
+The metrics pipeline in `inventory-server/scripts/calculate-metrics-new.js` runs 6 SQL scripts sequentially:
+
+1. `update_daily_snapshots.sql` — Aggregates daily per-product sales/receiving data
+2. `update_product_metrics.sql` — Calculates the main product_metrics table (KPIs, forecasting, status)
+3. `update_periodic_metrics.sql` — ABC classification, average lead time
+4. `calculate_brand_metrics.sql` — Brand-level aggregated metrics
+5. `calculate_vendor_metrics.sql` — Vendor-level aggregated metrics
+6. `calculate_category_metrics.sql` — Category-level metrics with hierarchy rollups
+
+### Database Scale
+| Table | Row Count |
+|---|---|
+| products | 681,912 |
+| orders | 2,883,982 |
+| purchase_orders | 256,809 |
+| receivings | 313,036 |
+| daily_product_snapshots | 678,312 (601 distinct dates, since 2024-06-01) |
+| product_metrics | 681,912 |
+| brand_metrics | 1,789 |
+| vendor_metrics | 281 |
+| category_metrics | 610 |
+
+---
+
+## Issues Found
+
+### ISSUE 1: [HIGH] Order status filter is non-functional — numeric codes vs text comparison
+
+**Files:** `update_daily_snapshots.sql` lines 86-101, `update_product_metrics.sql` lines 89, 178-183
+**Confirmed by data:** All order statuses are numeric strings ('100', '50', '55', etc.)
+**Status mappings from:** `docs/prod_registry.class.php`
+
+**Description:** The SQL filters `COALESCE(o.status, 'pending') NOT IN ('canceled', 'returned')` and `o.status NOT IN ('canceled', 'returned')` are used throughout the pipeline to exclude canceled/returned orders. However, the import pipeline stores order statuses as their **raw numeric codes** from the production MySQL database (e.g., '100', '50', '55', '90', '92'). There are **zero text status values** in the orders table.
+
+This means these filters **never exclude any rows** — every comparison is `'100' NOT IN ('canceled', 'returned')` which is always true.
+
+**Actual status distribution (with confirmed meanings):**
+| Status | Meaning | Count | Negative Qty | Assessment |
+|---|---|---|---|---|
+| 100 | shipped | 2,862,792 | 3,352 | Completed — correct to include |
+| 50 | awaiting_products | 11,109 | 0 | In-progress — not yet shipped |
+| 55 | shipping_later | 5,689 | 0 | In-progress — not yet shipped |
+| 56 | shipping_together | 2,863 | 0 | In-progress — not yet shipped |
+| 90 | awaiting_shipment | 38 | 0 | Near-complete — not yet shipped |
+| 92 | awaiting_pickup | 71 | 0 | Near-complete — awaiting customer |
+| 95 | shipped_confirmed | 5 | 0 | Completed — correct to include |
+| 15 | cancelled | 1 | 0 | Should be excluded |
+
+**Full status reference (from prod_registry.class.php):**
+- 0=created, 10=unfinished, **15=cancelled**, 16=combined, 20=placed, 22=placed_incomplete
+- 30=cancelled_old (historical), 40=awaiting_payment, 50=awaiting_products
+- 55=shipping_later, 56=shipping_together, 60=ready, 61=flagged
+- 62=fix_before_pick, 65=manual_picking, 70=in_pt, 80=picked
+- 90=awaiting_shipment, 91=remote_wait, **92=awaiting_pickup**, 93=fix_before_ship
+- **95=shipped_confirmed**, **100=shipped**
+
+**Severity revised to HIGH (from CRITICAL):** Now that we know the actual meanings, no cancelled/refunded orders are being miscounted (only 1 cancelled order exists, status=15). The real concern is twofold:
+1. **The text-based filter is dead code** — it can never match any row. Either map statuses to text during import (like POs do) or change SQL to use numeric comparisons.
+2. **~19,775 unfulfilled orders** (statuses 50/55/56/90/92) are counted as completed sales. These are orders in various stages of fulfillment that haven't shipped yet. While most will eventually ship, counting them now inflates current-period metrics. At 0.69% of total orders, the financial impact is modest but the filter should work correctly on principle.
+
+**Note:** PO statuses ARE properly mapped to text ('canceled', 'done', etc.) in the import pipeline. Only order statuses are numeric.
+
+---
+
+### ISSUE 2: [CRITICAL] Daily Snapshots use current stock instead of historical EOD stock
+
+**File:** `update_daily_snapshots.sql`, lines 126-135, 173
+**Confirmed by data:** Top product (pid 666925) shows `eod_stock_quantity = 0` for ALL dates even though it sold 28 units on Jan 28 (clearly had stock then)
+
+**Description:** The `CurrentStock` CTE reads `stock_quantity` directly from the `products` table at query execution time. When the script processes historical dates (today minus 1-4 days), it writes **today's stock** as if it were the end-of-day stock for those past dates.
+
+**Cascading impact on product_metrics:**
+- `avg_stock_units_30d` / `avg_stock_cost_30d` — Wrong averages
+- `stockout_days_30d` — Undercounts (only based on current stock state, not historical)
+- `stockout_rate_30d`, `service_level_30d`, `fill_rate_30d` — All derived from wrong stockout data
+- `gmroi_30d` — Wrong denominator (avg stock cost)
+- `stockturn_30d` — Wrong denominator (avg stock units)
+- `sell_through_30d` — Affected by stock level inaccuracy
+
+---
+
+### ISSUE 3: [CRITICAL] Snapshot coverage is 0.17% — most products have no snapshot data
+
+**Confirmed by data:** 678,312 snapshot rows across 601 dates = ~1,128 products/day out of 681,912 total
+
+**Description:** The daily snapshots script only creates rows for products with sales or receiving activity on that date (`ProductsWithActivity` CTE, line 136). This means:
+- 91.1% of products (621,221) have NULL `sales_30d` — they had no orders in the last 30 days so no snapshot rows exist
+- `AVG(eod_stock_quantity)` averages only across days with activity, not 30 days
+- `stockout_days_30d` only counts stockout days where there was ALSO some activity
+- A product out of stock with zero sales gets zero stockout_days even though it was stocked out
+
+This is by design (to avoid creating 681K rows/day) but means stock-related metrics are systematically biased.
+
+---
+
+### ISSUE 4: [HIGH] `costeach` fallback to 50% of price in import pipeline
+
+**File:** `inventory-server/scripts/import/orders.js` (line ~573)
+
+**Description:** When the MySQL `order_costs` table has no record for an order item, `costeach` defaults to `price * 0.5`. There is **no flag** in the PostgreSQL data to distinguish actual costs from estimated ones.
+
+**Data impact:** 385,545 products (56.5%) have `current_cost_price = 0` AND `current_landing_cost_price = 0`. For these products, the COGS calculation in daily_snapshots falls through the chain:
+1. `o.costeach` — May be the 50% estimate from import
+2. `get_weighted_avg_cost()` — Returns NULL if no receivings exist
+3. `p.landing_cost_price` — Always NULL (hardcoded in import)
+4. `p.cost_price` — 0 for 56.5% of products
+
+Only 27 products have zero COGS with positive sales, meaning the `costeach` field is doing its job for products that sell, but the 50% fallback means margins for those products are estimates, not actuals.
+
+---
+
+### ISSUE 5: [HIGH] `landing_cost_price` is always NULL
+
+**File:** `inventory-server/scripts/import/products.js` (line ~175)
+
+**Description:** The import explicitly sets `landing_cost_price = NULL` for all products. The daily_snapshots COGS calculation uses it as a fallback: `COALESCE(o.costeach, get_weighted_avg_cost(...), p.landing_cost_price, p.cost_price)`. Since it's always NULL, this fallback step is useless and the chain jumps straight to `cost_price`.
+
+The `product_metrics` field `current_landing_cost_price` is populated as `COALESCE(p.landing_cost_price, p.cost_price, 0.00)`, so it equals `cost_price` for all products. Any UI showing "landing cost" is actually just showing `cost_price`.
+
+---
+
+### ISSUE 6: [HIGH] Vendor lead time is drastically wrong — missing supplier_id join
+
+**File:** `calculate_vendor_metrics.sql`, lines 62-82
+**Confirmed by data:** Vendor-level lead times are 2-10x higher than product-level lead times
+
+**Description:** The vendor metrics lead time joins POs to receivings only by `pid`:
+```sql
+LEFT JOIN public.receivings r ON r.pid = po.pid
+```
+But the periodic metrics lead time correctly matches supplier:
+```sql
+JOIN public.receivings r ON r.pid = po.pid AND r.supplier_id = po.supplier_id
+```
+
+Without supplier matching, a PO for product X from Vendor A can match a receiving of product X from Vendor B, creating inflated/wrong lead times.
+
+**Measured discrepancies:**
+| Vendor | Vendor Metrics Lead Time | Avg Product Lead Time |
+|---|---|---|
+| doodlebug design inc. | 66 days | 14 days |
+| Notions | 55 days | 4 days |
+| Simple Stories | 59 days | 27 days |
+| Ranger Industries | 31 days | 5 days |
+
+---
+
+### ISSUE 7: [MEDIUM] Net revenue does not subtract returns
+
+**File:** `update_daily_snapshots.sql`, line 184
+
+**Description:** `net_revenue = gross_revenue - discounts`. Standard accounting: `net_revenue = gross_revenue - discounts - returns`. The `returns_revenue` is calculated separately but not deducted.
+
+**Data impact:** There are 3,352 orders with negative quantities (returns), totaling -5,499 units. These returns are tracked in `returns_revenue` but not reflected in `net_revenue`, which means all downstream revenue-based metrics are slightly overstated.
+
+---
+
+### ISSUE 8: [MEDIUM] Lifetime revenue subquery references wrong table columns
+
+**File:** `update_product_metrics.sql`, lines 323-329
+
+**Description:** The lifetime revenue estimation fallback queries:
+```sql
+SELECT revenue_7d / NULLIF(sales_7d, 0)
+FROM daily_product_snapshots
+WHERE pid = ci.pid AND sales_7d > 0
+```
+But `daily_product_snapshots` does NOT have `revenue_7d` or `sales_7d` columns — those exist in `product_metrics`. This subquery either errors silently or returns NULL. The effect is that the estimation always falls back to `current_price * total_sold`.
+
+---
+
+### ISSUE 9: [MEDIUM] Brand/Vendor metrics COGS filter inflates margins
+
+**Files:** `calculate_brand_metrics.sql` lines 31, `calculate_vendor_metrics.sql` line 32
+
+**Description:** `SUM(CASE WHEN pm.cogs_30d > 0 THEN pm.cogs_30d ELSE 0 END)` excludes products with zero COGS. But if a product has sales revenue and zero COGS (missing cost data), the brand/vendor totals will include the revenue but not the COGS, artificially inflating the margin.
+
+**Data context:** Brand metrics revenue matches product_metrics aggregation exactly for sales counts, but shows small discrepancies in revenue (e.g., Stamperia: $7,613.98 brand vs $7,611.11 actual). These tiny diffs come from the `> 0` filtering excluding products with negative revenue.
+
+---
+
+### ISSUE 10: [MEDIUM] Extreme margin values from $0.01 price orders
+
+**Confirmed by data:** 73 products with margin > 100%, 119 with margin < -100%
+
+**Examples:**
+| Product | Revenue | COGS | Margin |
+|---|---|---|---|
+| Flower Gift Box Die (pid 624756) | $0.02 | $29.98 | -149,800% |
+| Special Flowers Stamp Set (pid 614513) | $0.01 | $11.97 | -119,632% |
+
+These are products with extremely low prices (likely samples, promos, or data errors) where the order price was $0.01. The margin calculation is mathematically correct but these outliers skew any aggregate margin statistics.
+
+---
+
+### ISSUE 11: [MEDIUM] Sell-through rate has edge cases yielding negative/extreme values
+
+**File:** `update_product_metrics.sql`, lines 358-361
+**Confirmed by data:** 30 products with negative sell-through, 10 with sell-through > 200%
+
+**Description:** Beginning inventory is approximated as `current_stock + sales - received + returns`. When inventory adjustments, shrinkage, or manual corrections occur, this approximation breaks. Edge cases:
+- Products with many manual stock adjustments → negative denominator → negative sell-through
+- Products with beginning stock near zero but decent sales → sell-through > 100%
+
+---
+
+### ISSUE 12: [MEDIUM] `total_sold` uses different status filter than orders import
+
+**Import pipeline confirmed:**
+- Orders import: `order_status >= 15` (includes processing/pending orders)
+- `total_sold` in products: `order_status >= 20` (more restrictive)
+
+This means `lifetime_sales` (from `total_sold`) is systematically lower than what you'd calculate by summing the orders table. The discrepancy is confirmed:
+| Product | total_sold | orders sum | Gap |
+|---|---|---|---|
+| pid 31286 | 13,786 | 4,241 | 9,545 |
+| pid 44309 | 11,978 | 3,119 | 8,859 |
+
+The large gaps are because the orders table only has data from the import start date (~2024), while `total_sold` includes all-time sales from MySQL. This is expected behavior, not a bug, but it means the `lifetime_revenue_quality` flag is important — most products show 'estimated' quality.
+
+---
+
+### ISSUE 13: [MEDIUM] Category rollup may double-count products in multiple hierarchy levels
+
+**File:** `calculate_category_metrics.sql`, lines 42-66
+
+**Description:** The `RolledUpMetrics` CTE uses:
+```sql
+dcm.cat_id = ch.cat_id OR dcm.cat_id = ANY(SELECT cat_id FROM category_hierarchy WHERE ch.cat_id = ANY(ancestor_ids))
+```
+If products are assigned to categories at multiple levels in the same branch (e.g., both "Paper Crafts" and "Scrapbook Paper" which is a child of "Paper Crafts"), those products' metrics would be counted twice in the parent's rollup.
+
+---
+
+### ISSUE 14: [LOW] `exclude_forecast` removes products from metrics entirely
+
+**File:** `update_product_metrics.sql`, line 509
+
+**Description:** `WHERE s.exclude_forecast IS FALSE OR s.exclude_forecast IS NULL` is on the main INSERT's WHERE clause. Products with `exclude_forecast = TRUE` won't appear in `product_metrics` at all, rather than just having forecast fields nulled. Currently all 681,912 products are in product_metrics so this appears to not affect any products yet.
+
+---
+
+### ISSUE 15: [LOW] Daily snapshots only look back 5 days
+
+**File:** `update_daily_snapshots.sql`, line 14 — `_process_days INT := 5`
+
+If import data arrives late (>5 days), those days will never get snapshots populated. There is a separate `backfill/rebuild_daily_snapshots.sql` for historical rebuilds.
+
+---
+
+### ISSUE 16: [INFO] Timezone risk in order date import
+
+**File:** `inventory-server/scripts/import/orders.js`
+
+MySQL `DATETIME` values are timezone-naive. The import uses `new Date(order.date)` which interprets them using the import server's local timezone. The SSH config specifies `timezone: '-05:00'` for MySQL (always EST). If the import server is in a different timezone, orders near midnight could land on the wrong date in the daily snapshots calculation.
+
+---
+
+## Custom Functions Review
+
+### `calculate_sales_velocity(sales_30d, stockout_days_30d)`
+- Divides `sales_30d` by effective selling days: `GREATEST(30 - stockout_days, CASE WHEN sales > 0 THEN 14 ELSE 30 END)`
+- The 14-day floor prevents extreme velocity for products mostly out of stock
+- **Sound approach** — the only concern is that stockout_days is unreliable (Issues 2, 3)
+
+### `get_weighted_avg_cost(pid, date)`
+- Weighted average of last 10 receivings by cost*qty/qty
+- Returns NULL if no receivings — sound fallback behavior
+- **Correct implementation**
+
+### `safe_divide(numerator, denominator)`
+- Returns NULL on divide-by-zero — **correct**
+
+### `std_numeric(value, precision)`
+- Rounds to precision digits — **correct**
+
+### `classify_demand_pattern(avg_demand, cv)`
+- Uses coefficient of variation thresholds: ≤0.2 = stable, ≤0.5 = variable, low-volume+high-CV = sporadic, else lumpy
+- **Reasonable classification**, though only based on 30-day window
+
+### `detect_seasonal_pattern(pid)`
+- CROSS JOIN LATERAL (runs per product) — **expensive**: queries `daily_product_snapshots` twice per product
+- Compares current month average to yearly average — very simplistic
+- **Functional but could be a performance bottleneck** with 681K products
+
+### `category_hierarchy` (materialized view)
+- Recursive CTE building tree from categories — **correct implementation**
+- Refreshed concurrently before category metrics calculation — **good practice**
+
+---
+
+## Data Health Summary
+
+| Metric | Count | % of Total |
+|---|---|---|
+| Products with zero cost_price | 385,545 | 56.5% |
+| Products with NULL sales_30d | 621,221 | 91.1% |
+| Products with no lifetime_sales | 321,321 | 47.1% |
+| Products with zero COGS but positive sales | 27 | <0.01% |
+| Products with margin > 100% | 73 | <0.01% |
+| Products with margin < -100% | 119 | <0.01% |
+| Products with negative sell-through | 30 | <0.01% |
+| Products with NULL status | 0 | 0% |
+| Duplicate daily snapshots (same pid+date) | 0 | 0% |
+| Net revenue formula mismatches | 0 | 0% |
+
+### ABC Classification Distribution (replenishable products only)
+| Class | Products | Revenue % |
+|---|---|---|
+| A | 7,727 | 80.72% |
+| B | 12,048 | 15.10% |
+| C | 113,647 | 4.18% |
+
+ABC distribution looks healthy — A ≈ 80%, A+B ≈ 96%.
+
+### Brand Metrics Consistency
+Product counts and sales_30d match exactly between `brand_metrics` and direct aggregation from `product_metrics`. Revenue shows sub-dollar discrepancies due to the `> 0` filter excluding products with negative revenue. **Consistent within expected tolerance.**
+
+---
+
+## Priority Recommendations
+
+### Must Fix (Correctness Issues)
+1. **Issue 1: Fix order status handling** — The text-based filter (`NOT IN ('canceled', 'returned')`) is dead code against numeric statuses. Two options: (a) map numeric statuses to text during import (like POs already do), or (b) change SQL to filter on numeric codes (e.g., `o.status::int >= 20` to exclude cancelled/unfinished, or `o.status IN ('100', '95')` for shipped-only). The ~19.7K unfulfilled orders (0.69%) are a minor financial impact but the filter should be functional.
+2. **Issue 6: Add supplier_id join to vendor lead time** — One-line fix in `calculate_vendor_metrics.sql`
+3. **Issue 8: Fix lifetime revenue subquery** — Use correct column names from `daily_product_snapshots` (e.g., `net_revenue / NULLIF(units_sold, 0)`)
+
+### Should Fix (Data Quality)
+4. **Issue 2/3: Snapshot coverage** — Consider creating snapshot rows for all in-stock products, not just those with activity. Or at minimum, calculate stockout metrics by comparing snapshot existence to product existence.
+5. **Issue 5: Populate landing_cost_price** — If available in the source system, import it. Otherwise remove references to avoid confusion.
+6. **Issue 7: Subtract returns from net_revenue** — `net_revenue = gross_revenue - discounts - returns_revenue`
+7. **Issue 9: Remove > 0 filter on COGS** — Use `SUM(pm.cogs_30d)` instead of conditional sums
+
+### Nice to Fix (Edge Cases)
+8. **Issue 4: Flag estimated costs** — Add a `costeach_estimated BOOLEAN` to orders during import
+9. **Issue 10: Cap or flag extreme margins** — Exclude $0.01-price orders from margin calculations
+10. **Issue 11: Clamp sell-through** — `GREATEST(0, LEAST(sell_through_30d, 200))` or flag outliers
+11. **Issue 12: Verify category assignment policy** — Check if products are assigned to leaf categories only
+12. **Issue 13: Category rollup query** — Verify no double-counting with actual data

docs/METRICS_AUDIT2.md

@@ -0,0 +1,276 @@
+# Metrics Pipeline Audit Report
+
+**Date:** 2026-02-08
+**Scope:** All 6 SQL scripts in `inventory-server/scripts/metrics-new/`, import pipeline, custom functions, and post-calculation data verification.
+
+---
+
+## Executive Summary
+
+The metrics pipeline is architecturally sound and the core calculations are mostly correct. The 30-day sales, revenue, replenishment, and aggregate metrics (brand/vendor/category) all cross-check accurately between the snapshots, product_metrics, and direct orders queries. However, several issues were found ranging from **critical data bugs** to **design limitations** that affect accuracy of specific metrics.
+
+**Issues found: 13** (3 Critical, 4 Medium, 6 Low/Informational)
+
+---
+
+## CRITICAL Issues
+
+### C1. `net_revenue` in daily snapshots never subtracts returns ($35.6K affected)
+
+**Location:** `update_daily_snapshots.sql`, line 181
+**Symptom:** `net_revenue` is stored as `gross_revenue - discounts` but should be `gross_revenue - discounts - returns_revenue`.
+
+The SQL formula on line 181 appears correct:
+```sql
+COALESCE(sd.gross_revenue_unadjusted, 0.00) - COALESCE(sd.discounts, 0.00) - COALESCE(sd.returns_revenue, 0.00) AS net_revenue
+```
+
+However, actual data shows `net_revenue = gross_revenue - discounts` for ALL 3,252 snapshots that have returns. Total returns not subtracted: **$35,630.03** across 2,946 products. This may be caused by the `returns_revenue` in the SalesData CTE not properly flowing through to the INSERT, or by a prior version of the code that stored these values differently. The profit column (line 184) has the same issue: `(gross - discounts) - cogs` instead of `(gross - discounts - returns) - cogs`.
+
+**Impact:** Net revenue and profit are overstated by the amount of returns. This cascades to all metrics derived from snapshots: `revenue_30d`, `profit_30d`, `margin_30d`, `avg_ros_30d`, and all brand/vendor/category aggregate revenue.
+
+**Recommended fix:** Debug why the returns subtraction isn't taking effect. The formula in the SQL looks correct, so this may be a data-type issue or an execution path issue. After fixing, rebuild snapshots.
+
+**Status:** Owner will resolve. Code formula is correct; snapshots need rebuilding after prior fix deployment.
+
+---
+
+### C2. `eod_stock_quantity` uses CURRENT stock, not historical end-of-day stock
+
+**Location:** `update_daily_snapshots.sql`, lines 123-132 (CurrentStock CTE)
+**Symptom:** Every snapshot for a given product shows the same stock quantity regardless of the snapshot date.
+
+The `CurrentStock` CTE simply reads `stock_quantity` from the `products` table:
+```sql
+SELECT pid, stock_quantity, ... FROM public.products
+```
+
+This means a snapshot from January 10 shows the SAME stock as today (February 8). Verified in data:
+- Product 662561: stock = 36 on every date (Feb 1-7)
+- Product 665397: stock = 25 on every date (Feb 1-7)
+- All products checked show identical stock across all snapshot dates
+
+**Impact:** All stock-derived metrics are inaccurate for historical analysis:
+- `eod_stock_cost`, `eod_stock_retail`, `eod_stock_gross` (all wrong for past dates)
+- `stockout_flag` (based on current stock, not historical)
+- `stockout_days_30d` (undercounted since stockout_flag uses current stock)
+- `avg_stock_units_30d`, `avg_stock_cost_30d` (no variance, just current stock repeated)
+- `gmroi_30d`, `stockturn_30d` (based on avg_stock which is flat)
+- `sell_through_30d` (denominator uses current stock assumption)
+- `service_level_30d`, `fill_rate_30d`
+
+**This is a known architectural limitation** noted in MEMORY.md. Fixing requires either:
+1. Storing stock snapshots separately at end-of-day (ideally via a cron job that records stock before any changes)
+2. Reconstructing historical stock from orders and receivings (complex but possible)
+
+**Status: FIXED.** MySQL's `snap_product_value` table (daily EOD stock per product since 2012) is now imported into PostgreSQL `stock_snapshots` table via `scripts/import/stock-snapshots.js`. The `CurrentStock` CTE in `update_daily_snapshots.sql` now uses `LEFT JOIN stock_snapshots` for historical stock, falling back to `products.stock_quantity` when no historical data exists. Requires: run import, then rebuild daily snapshots.
+
+---
+
+### C3. `ON CONFLICT DO UPDATE WHERE` check skips 91%+ of product_metrics updates
+
+**Location:** `update_product_metrics.sql`, lines 558-574
+**Symptom:** 623,205 of 681,912 products (91.4%) have `last_calculated` older than 1 day. 592,369 are over 30 days old. 914 products with active 30-day sales haven't been updated in over 7 days.
+
+The upsert's `WHERE` clause only updates if specific fields changed:
+```sql
+WHERE product_metrics.current_stock IS DISTINCT FROM EXCLUDED.current_stock OR
+      product_metrics.current_price IS DISTINCT FROM EXCLUDED.current_price OR ...
+```
+
+Fields NOT checked include: `stockout_days_30d`, `margin_30d`, `gmroi_30d`, `demand_pattern`, `seasonality_index`, `sales_growth_*`, `service_level_30d`, and many others. If a product's stock, price, sales, and revenue haven't changed, the entire row is skipped even though growth metrics, variability, and other derived fields may need updating.
+
+**Impact:** Most derived metrics (growth, demand patterns, seasonality) are stale for the majority of products. Products with steady sales but unchanged stock/price never get their growth metrics recalculated.
+
+**Recommended fix:** Either:
+1. Remove the `WHERE` clause entirely (accept the performance cost of writing all rows every run)
+2. Add `last_calculated` age check: `OR product_metrics.last_calculated < NOW() - INTERVAL '7 days'`
+3. Add the missing fields to the change-detection check
+
+**Status: FIXED.** Added 12 derived fields to the `IS DISTINCT FROM` check (`profit_30d`, `cogs_30d`, `margin_30d`, `stockout_days_30d`, `sell_through_30d`, `sales_growth_30d_vs_prev`, `revenue_growth_30d_vs_prev`, `demand_pattern`, `seasonal_pattern`, `seasonality_index`, `service_level_30d`, `fill_rate_30d`) plus a time-based safety net: `OR product_metrics.last_calculated < NOW() - INTERVAL '1 day'`. This guarantees every row is refreshed at least daily.
+
+---
+
+## MEDIUM Issues
+
+### M1. Demand variability calculated only over activity days, not full 30-day window
+
+**Location:** `update_product_metrics.sql`, DemandVariability CTE (lines 206-223)
+**Symptom:** Variance, std_dev, and CV are computed over only the days that appear in snapshots (activity days), not the full 30-day period including zero-sales days.
+
+Example: Product 41141 (Mexican Poppy) sold 102 units in 30 days across only 3 snapshot days (1, 1, 100). The variance/CV is calculated over just those 3 data points instead of 30 (with 27 zero-sales days).
+
+**Impact:**
+- CV is computed on sparse data (3-10 points instead of 30), making it statistically unreliable
+- Products with sporadic large orders appear less variable than they really are
+- `demand_pattern` classification is affected (stable/variable/sporadic/lumpy)
+
+**Recommended fix:** Join against a generated 30-day date series and COALESCE missing days to 0 units sold before computing variance/stddev/CV.
+
+**Status: FIXED.** Rewrote `DemandVariability` CTE to use `generate_series()` for the full 30-day date range, `CROSS JOIN` with distinct PIDs from snapshots, and `LEFT JOIN` actual snapshot data with `COALESCE(dps.units_sold, 0)` for missing days. Variance/stddev/CV now computed over all 30 data points.
+
+---
+
+### M2. `costeach` fallback to `price * 0.5` affects 32.5% of recent orders
+
+**Location:** `orders.js`, line 600 and 634
+**Symptom:** When no cost record exists in `order_costs`, the import falls back to `price * 0.5`.
+
+Data shows 9,839 of 30,266 recent orders (32.5%) use this fallback. Among these, 79 paid products have `costeach = 0` because `price = 0 * 0.5 = 0`, even though the product has a real cost_price.
+
+The daily snapshot has a second line of defense (using `get_weighted_avg_cost()` and then `p.cost_price`), but the orders table's `costeach` column itself contains inaccurate data for ~1/3 of orders.
+
+**Impact:** COGS calculations at the order level are approximate for 1/3 of orders. The snapshot's fallback chain mitigates this somewhat, but any analytics using `orders.costeach` directly will be affected.
+
+**Status: FIXED.** Added `products.cost_price` as intermediate fallback: `COALESCE(oc.costeach, p.cost_price, oi.price * 0.5)`. The products table join was added to both the `order_totals` CTE and the outer SELECT in `orders.js`. Requires a full orders re-import to apply retroactively.
+
+---
+
+### M3. `lifetime_sales` uses MySQL `total_sold` (status >= 20) but orders import uses status >= 15
+
+**Location:** `products.js` line 200 vs `orders.js` line 69
+**Symptom:** `total_sold` in the products table comes from MySQL with `order_status >= 20`, excluding status 15 (canceled) and 16 (combined). But the orders import fetches orders with `order_status >= 15`.
+
+Verified in MySQL: For product 31286, `total_sold` (>=20) = 13,786 vs (>=15) = 13,905 (difference of 119 units).
+
+**Impact:** `lifetime_sales` in product_metrics (sourced from `products.total_sold`) slightly understates compared to what the orders table contains. The `lifetime_revenue_quality` field correctly flags most as "estimated" since the orders table only covers ~5 years while `total_sold` is all-time. This is a minor inconsistency (< 1% difference).
+
+**Status:** Accepted. < 1% difference, not worth the complexity of aligning thresholds.
+
+---
+
+### M4. `sell_through_30d` has 868 NULL values and 547 anomalous values for products with sales
+
+**Location:** `update_product_metrics.sql`, lines 356-361
+**Formula:** `(sales_30d / (current_stock + sales_30d + returns_units_30d - received_qty_30d)) * 100`
+
+- 868 products with sales but NULL sell_through (denominator = 0, which happens when `current_stock + sales - received = 0`, i.e. all stock came from receiving and was sold)
+- 259 products with sell_through > 100%
+- 288 products with negative sell_through
+
+**Impact:** Sell-through rate is unreliable for products with significant receiving activity in the same period. The formula tries to approximate "beginning inventory" but the approximation breaks when current stock ≠ actual beginning stock (which is always, per issue C2).
+
+**Status:** Will improve once C2 fix (historical stock) is deployed and snapshots are rebuilt, since `current_stock` in the formula will then reflect actual beginning inventory.
+
+---
+
+## LOW / INFORMATIONAL Issues
+
+### L1. Snapshots only cover ~1,167 products/day out of 681K
+
+Only products with order or receiving activity on a given day get snapshots. This is by design (the `ProductsWithActivity` CTE on line 133 of `update_daily_snapshots.sql`), but it means:
+- 560K+ products have zero snapshot history
+- Stockout tracking is impossible for products with no sales (they can't appear in snapshots)
+- The "avg_stock" metrics (avg_stock_units_30d, etc.) only average over activity days, not all 30 days
+
+This is acceptable for storage efficiency but should be understood when interpreting metrics.
+
+**Status:** Accepted (by design).
+
+---
+
+### L2. `detect_seasonal_pattern` function only compares current month to yearly average
+
+The seasonality detection is simplistic: it compares current month's avg daily sales to yearly avg. This means:
+- It can only detect if the CURRENT month is above average, not identify historical seasonal patterns
+- Running in January vs July will give completely different results for the same product
+- The "peak_season" field always shows the current month/quarter when seasonal (not the actual peak)
+
+This is noted as a P5 (low priority) feature and is adequate for a first pass but should not be relied upon for demand planning.
+
+**Status: FIXED.** Rewrote `detect_seasonal_pattern` function to compare monthly average sales across the full last 12 months. Uses CV across months + peak-to-average ratio for classification: `strong` (CV > 0.5, peak > 150%), `moderate` (CV > 0.3, peak > 120%), `none`. Peak season now identifies the actual highest-sales month. Requires at least 3 months of data. Saved in `db/functions.sql`.
+
+---
+
+### L3. Free product with negative revenue in top sellers
+
+Product 476848 ("Thank You, From ACOT!") shows 254 sales with -$1.00 revenue because one order applied a $1 discount to a $0 product. This is a data oddity, not a calculation bug. Could be addressed by excluding $0-price products from revenue metrics or by data cleanup.
+
+**Status:** Accepted (data oddity, not a bug).
+
+---
+
+### L4. `landing_cost_price` is always NULL
+
+`current_landing_cost_price` in product_metrics is mapped from `current_effective_cost` which is just `cost_price`. The `landing_cost_price` concept (cost + shipping + duties) is not implemented. The field exists but has no meaningful data.
+
+**Status: FIXED.** Removed `landing_cost_price` from `db/schema.sql`, `current_landing_cost_price` from `db/metrics-schema-new.sql`, `update_product_metrics.sql`, and `backfill/populate_initial_product_metrics.sql`. Column should be dropped from the live database via `ALTER TABLE`.
+
+---
+
+### L5. Custom SQL functions not tracked in version control
+
+All 6 custom functions (`calculate_sales_velocity`, `get_weighted_avg_cost`, `safe_divide`, `std_numeric`, `classify_demand_pattern`, `detect_seasonal_pattern`) and the `category_hierarchy` materialized view exist only in the database. They are not defined in any migration or schema file in the repository.
+
+If the database needs to be recreated, these would be lost.
+
+**Status: FIXED.** All 6 functions and the `category_hierarchy` materialized view definition saved to `inventory-server/db/functions.sql`. File is re-runnable via `psql -f functions.sql`.
+
+---
+
+### L6. `get_weighted_avg_cost` limited to last 10 receivings
+
+The function `LIMIT 10` for performance, but this means products with many small receivings may not accurately reflect the true weighted average cost if the cost has changed significantly beyond the last 10 receiving records.
+
+**Status: FIXED.** Removed `LIMIT 10` from `get_weighted_avg_cost`. Data shows max receivings per product is 142 (p95 = 11, avg = 3), so performance impact is negligible. Updated definition in `db/functions.sql`.
+
+---
+
+## Verification Summary
+
+### What's Working Correctly
+
+| Check | Result |
+|-------|--------|
+| 30d sales: product_metrics vs orders vs snapshots | **MATCH** (verified top 10 sellers) |
+| Replenishment formula: manual calc vs stored | **MATCH** (verified 10 products) |
+| Brand metrics vs sum of product_metrics | **MATCH** (0 difference across all brands) |
+| Order status mapping (numeric → text) | **CORRECT** (all statuses mapped, no numeric remain) |
+| Cost price: PostgreSQL vs MySQL source | **MATCH** (within rounding, verified 5 products) |
+| total_sold: PostgreSQL vs MySQL source | **MATCH** (verified 5 products) |
+| Category rollups (rolled-up > direct for parents) | **CORRECT** |
+| ABC classification distribution | **REASONABLE** (A: 8K, B: 12.5K, C: 113K) |
+| Lead time calculation (PO → receiving) | **CORRECT** (verified examples) |
+
+### Data Overview
+
+| Metric | Value |
+|--------|-------|
+| Total products | 681,912 |
+| Products in product_metrics | 681,912 (100%) |
+| Products with 30d sales | 10,291 (1.5%) |
+| Products with negative profit & revenue | 139 (mostly cost > price) |
+| Products with negative stock | 0 |
+| Snapshot date range | 2020-06-18 to 2026-02-08 |
+| Avg products per snapshot day | 1,167 |
+| Order date range | 2020-06-18 to 2026-02-08 |
+| Total orders | 2,885,825 |
+| 'returned' status orders | 0 (returns via negative quantity only) |
+
+---
+
+## Fix Status Summary
+
+| Issue | Severity | Status | Deployment Action Needed |
+|-------|----------|--------|--------------------------|
+| C1 | Critical | Owner resolving | Rebuild daily snapshots |
+| C2 | Critical | **FIXED** | Run import, rebuild daily snapshots |
+| C3 | Critical | **FIXED** | Deploy updated `update_product_metrics.sql` |
+| M1 | Medium | **FIXED** | Deploy updated `update_product_metrics.sql` |
+| M2 | Medium | **FIXED** | Full orders re-import (`--full`) |
+| M3 | Medium | Accepted | None |
+| M4 | Medium | Pending C2 | Will improve after C2 deployment |
+| L1 | Low | Accepted | None |
+| L2 | Low | **FIXED** | Deploy `db/functions.sql` to database |
+| L3 | Low | Accepted | None |
+| L4 | Low | **FIXED** | `ALTER TABLE` to drop columns |
+| L5 | Low | **FIXED** | None (file committed) |
+| L6 | Low | **FIXED** | Deploy `db/functions.sql` to database |
+
+### Deployment Steps
+
+1. Deploy `db/functions.sql` to PostgreSQL: `psql -d inventory_db -f db/functions.sql` (L2, L6)
+2. Run import (includes stock snapshots first load) (C2, M2)
+3. Drop stale columns: `ALTER TABLE products DROP COLUMN IF EXISTS landing_cost_price; ALTER TABLE product_metrics DROP COLUMN IF EXISTS current_landing_cost_price;` (L4)
+4. Rebuild daily snapshots (C1, C2)
+5. Re-run metrics calculation (C3, M1 take effect automatically)

docs/PERMISSIONS.md

@@ -7,12 +7,13 @@ This document outlines the permission system implemented in the Inventory Manage
 Permissions follow this naming convention:
 
 - Page access: `access:{page_name}`
-- Actions: `{action}:{resource}`
+- Settings sections: `settings:{section_name}`
+- Admin features: `admin:{feature}`
 
 Examples:
 - `access:products` - Can access the Products page
-- `create:products` - Can create new products
-- `edit:users` - Can edit user accounts
+- `settings:user_management` - Can access User Management settings
+- `admin:debug` - Can see debug information
 
 ## Permission Components
 
@@ -22,10 +23,10 @@ The core component that conditionally renders content based on permissions.
 
 ```tsx
 <PermissionGuard 
-  permission="create:products"
+  permission="settings:user_management"
   fallback={<p>No permission</p>}
 >
-  <button>Create Product</button>
+  <button>Manage Users</button>
 </PermissionGuard>
 ```
 
@@ -81,7 +82,7 @@ Specific component for settings with built-in permission checks.
 <SettingsSection
   title="System Settings"
   description="Configure global settings"
-  permission="edit:system_settings"
+  permission="settings:global"
 >
   {/* Settings content */}
 </SettingsSection>
@@ -95,8 +96,8 @@ Core hook for checking any permission.
 
 ```tsx
 const { hasPermission, hasPageAccess, isAdmin } = usePermissions();
-if (hasPermission('delete:products')) {
-  // Can delete products
+if (hasPermission('settings:user_management')) {
+  // Can access user management
 }
 ```
 
@@ -106,8 +107,8 @@ Specialized hook for page-level permissions.
 
 ```tsx
 const { canView, canCreate, canEdit, canDelete } = usePagePermission('products');
-if (canEdit()) {
-  // Can edit products
+if (canView()) {
+  // Can view products
 }
 ```
 
@@ -119,18 +120,43 @@ Permissions are stored in the database:
 
 Admin users automatically have all permissions.
 
-## Common Permission Codes
+## Implemented Permission Codes
 
+### Page Access Permissions
 | Code | Description |
 |------|-------------|
 | `access:dashboard` | Access to Dashboard page |
+| `access:overview` | Access to Overview page |
 | `access:products` | Access to Products page |
-| `create:products` | Create new products |
-| `edit:products` | Edit existing products |
-| `delete:products` | Delete products |
-| `view:users` | View user accounts |
-| `edit:users` | Edit user accounts |
-| `manage:permissions` | Assign permissions to users |
+| `access:categories` | Access to Categories page |
+| `access:brands` | Access to Brands page |
+| `access:vendors` | Access to Vendors page |
+| `access:purchase_orders` | Access to Purchase Orders page |
+| `access:analytics` | Access to Analytics page |
+| `access:forecasting` | Access to Forecasting page |
+| `access:import` | Access to Import page |
+| `access:settings` | Access to Settings page |
+| `access:chat` | Access to Chat Archive page |
+
+### Settings Permissions
+| Code | Description |
+|------|-------------|
+| `settings:global` | Access to Global Settings section |
+| `settings:products` | Access to Product Settings section |
+| `settings:vendors` | Access to Vendor Settings section |
+| `settings:data_management` | Access to Data Management settings |
+| `settings:calculation_settings` | Access to Calculation Settings |
+| `settings:library_management` | Access to Image Library Management |
+| `settings:performance_metrics` | Access to Performance Metrics |
+| `settings:prompt_management` | Access to AI Prompt Management |
+| `settings:stock_management` | Access to Stock Management |
+| `settings:templates` | Access to Template Management |
+| `settings:user_management` | Access to User Management |
+
+### Admin Permissions
+| Code | Description |
+|------|-------------|
+| `admin:debug` | Can see debug information and features |
 
 ## Implementation Examples
 
@@ -148,25 +174,31 @@ In `App.tsx`:
 ### Component Level Protection
 
 ```tsx
-const { canEdit } = usePagePermission('products');
+const { hasPermission } = usePermissions();
 
-function handleEdit() {
-  if (!canEdit()) {
+function handleAction() {
+  if (!hasPermission('settings:user_management')) {
     toast.error("You don't have permission");
     return;
   }
-  // Edit logic
+  // Action logic
 }
 ```
 
 ### UI Element Protection
 
 ```tsx
-<PermissionButton 
-  page="products" 
-  action="delete"
-  onClick={handleDelete}
->
-  Delete
-</PermissionButton>
-``` 
+<PermissionGuard permission="settings:user_management">
+  <button onClick={handleManageUsers}>
+    Manage Users
+  </button>
+</PermissionGuard>
+```
+
+## Notes
+
+- **Page Access**: These permissions control which pages a user can navigate to
+- **Settings Access**: These permissions control access to different sections within the Settings page
+- **Admin Features**: Special permissions for administrative functions
+- **CRUD Operations**: The application currently focuses on viewing and managing data rather than creating/editing/deleting individual records
+- **User Management**: User CRUD operations are handled through the settings interface rather than dedicated user management pages 

docs/routes-cleanup.md

@@ -0,0 +1,271 @@
+**Analysis of Potential Issues**
+
+1.  **Obsolete Functionality:**
+    *   **`config.js` Legacy Endpoints:** The endpoints `GET /config/`, `PUT /config/stock-thresholds/:id`, `PUT /config/lead-time-thresholds/:id`, `PUT /config/sales-velocity/:id`, `PUT /config/abc-classification/:id`, `PUT /config/safety-stock/:id`, and `PUT /config/turnover/:id` appear **highly likely to be obsolete**. They reference older, single-row config tables (`stock_thresholds`, etc.) while newer endpoints (`/config/global`, `/config/products`, `/config/vendors`) manage settings in more structured tables (`settings_global`, `settings_product`, `settings_vendor`). Unless specifically required for backward compatibility, these legacy endpoints should be removed to avoid confusion and potential data conflicts.
+    *   **`analytics.js` Forecast Endpoint (`GET /analytics/forecast`):** This endpoint uses **MySQL syntax** (`DATEDIFF`, `DATE_FORMAT`, `JSON_OBJECT`, `?` placeholders) but seems intended to run within the analytics module which otherwise uses PostgreSQL (`req.app.locals.pool`, `date_trunc`, `::text`, `$1` placeholders). This endpoint is likely **obsolete or misplaced** and will not function correctly against the PostgreSQL database.
+    *   **`csv.js` Redundant Actions:**
+        *   `POST /csv/update` seems redundant with `POST /csv/full-update`. The latter uses the `runScript` helper and dedicated state (`activeFullUpdate`), appearing more robust. `/csv/update` might be older or incomplete.
+        *   `POST /csv/reset` seems redundant with `POST /csv/full-reset`. Similar reasoning applies; `/csv/full-reset` appears preferred.
+    *   **`products.js` Import Endpoint (`POST /products/import`):** This is **dangerous duplication**. The `/csv` module handles imports (`/csv/import`, `/csv/import-from-prod`) with locking (`activeImport`) to prevent concurrent operations. This endpoint lacks such locking and could corrupt data if run simultaneously with other CSV/reset operations. It should likely be removed.
+    *   **`products.js` Metrics Endpoint (`GET /products/:id/metrics`):** This is redundant. The `/metrics/:pid` endpoint provides the same, possibly more comprehensive, data directly from the `product_metrics` table. Clients should use `/metrics/:pid` instead.
+
+2.  **Overlap or Inappropriate Duplication of Effort:**
+    *   **AI Prompt Getters:** `GET /ai-prompts/type/general` and `GET /ai-prompts/type/system` could potentially be handled by adding a query parameter filter to `GET /ai-prompts/` (e.g., `GET /ai-prompts?prompt_type=general`). However, dedicated endpoints for single, specific items can sometimes be simpler. This is more of a design choice than a major issue.
+    *   **Vendor Performance/Metrics:** There are multiple ways to get vendor performance data:
+        *   `GET /analytics/vendors` (uses `vendor_metrics`)
+        *   `GET /dashboard/vendor/performance` (uses `purchase_orders`)
+        *   `GET /purchase-orders/vendor-metrics` (uses `purchase_orders`)
+        *   `GET /vendors-aggregate/` (uses `vendor_metrics`, augmented with `purchase_orders`)
+        This suggests significant overlap. The `/vendors-aggregate` endpoint seems the most comprehensive, combining pre-aggregated data with some real-time info. The others, especially `/dashboard/vendor/performance` and `/purchase-orders/vendor-metrics` which calculate directly from `purchase_orders`, might be redundant or less performant.
+    *   **Product Listing:**
+        *   `GET /products/` lists products joining `products`, `product_metrics`, and `categories`.
+        *   `GET /metrics/` lists products primarily from `product_metrics`.
+        They offer similar filtering/sorting. If `product_metrics` contains all necessary display fields, `GET /products/` might be partly redundant for simple listing views, although it does provide aggregated category names. Evaluate if both full list endpoints are necessary.
+    *   **Image Uploads/Management:** Image handling is split:
+        *   `products-import.js`: Uploads temporary images for product import to `/uploads/products/`, schedules deletion.
+        *   `reusable-images.js`: Uploads persistent images to `/uploads/reusable/`, stores metadata in DB.
+        *   `products-import.js` has `/check-file` and `/list-uploads` that can see *both* directories, while `reusable-images.js` has a `/check-file` that only sees its own. This separation could be confusing. Clarify the purpose and lifecycle of images in each directory.
+    *   **Background Task Management (`csv.js`):** The use of `activeImport` for multiple unrelated tasks (import, reset, metrics calc) prevents concurrency, which might be too restrictive. The cancellation logic (`/cancel`) only targets `full-update`/`full-reset`, not tasks locked by `activeImport`. This needs unification.
+    *   **Analytics/Dashboard Base Table Queries:** Several endpoints in `analytics.js` (`/pricing`, `/categories`) and `dashboard.js` (`/best-sellers`, `/sales/metrics`, `/trending/products`, `/key-metrics`, `/inventory-health`, `/sales-overview`) query base tables (`orders`, `products`, `purchase_orders`) directly, while many others leverage pre-aggregated `_metrics` tables. This inconsistency can lead to performance differences and suggests potential for optimization by using aggregates where possible.
+
+3.  **Obvious Mistakes / Data Issues:**
+    *   **AI Prompt Fetching:** `GET /ai-prompts/company/:companyId`, `/type/general`, `/type/system` return `result.rows[0]`. This assumes uniqueness. If the underlying DB constraints (`unique_company_prompt`, etc.) fail or aren't present, this could silently hide data if multiple rows match. The use of unique constraint handling in POST/PUT suggests this is likely intended and safe *if* DB constraints are solid.
+    *   **Mixed Databases & SSH Tunnels:** The heavy reliance in `ai_validation.js` and `products-import.js` on connecting to a production MySQL DB via SSH tunnel while also using a local PostgreSQL DB adds significant architectural complexity.
+        *   **Inefficiency:** In `ai_validation.js` (`generateDebugResponse`), an SSH tunnel and MySQL connection (`promptTunnel`, `promptConnection`) are established but seem unused when fetching prompts (which correctly come from the PG pool `res.app.locals.pool`). This is wasted effort.
+        *   **Improvement:** The `getDbConnection` function in `products-import.js` implements caching/pooling for the SSH/MySQL connection – this is much better and should ideally be used consistently wherever the production DB is accessed (e.g., in `ai_validation.js`).
+    *   **`products.js` Brand Filtering:** `GET /products/brands` filters brands based on having associated purchase orders with a cost >= 500. This seems arbitrary for a general list of brands and might return incomplete results depending on the use case.
+    *   **Type Handling:** Ensure `parseValue` handles all required types and edge cases correctly, especially for filtering complex queries in `*-aggregate` and `metrics` routes. Explicit type casting in SQL (`::numeric`, `::text`, etc.) is generally good practice in PostgreSQL.
+    *   **Dummy Data:** Several `dashboard.js` endpoints return hardcoded dummy data on errors or when no data is found. While this prevents UI crashes, it can mask real issues. Ensure logging is robust when fallbacks are used.
+
+**Summary of Endpoints**
+
+Here's a summary of the available endpoints, grouped by their likely file/module:
+
+**1. AI Prompts (`ai_prompts.js`)**
+    *   `GET /`: Get all AI prompts.
+    *   `GET /:id`: Get a specific AI prompt by its ID.
+    *   `GET /company/:companyId`: Get the AI prompt for a specific company (expects one). **(Deprecated)**
+    *   `GET /type/general`: Get the general AI prompt (expects one). **(Deprecated)**
+    *   `GET /type/system`: Get the system AI prompt (expects one). **(Deprecated)**
+    *   `GET /by-type`: Get AI prompt by type (general, system, company_specific) with optional company parameter. **(New Consolidated Endpoint)**
+    *   `POST /`: Create a new AI prompt.
+    *   `PUT /:id`: Update an existing AI prompt.
+    *   `DELETE /:id`: Delete an AI prompt.
+
+**2. AI Validation (`ai_validation.js`)**
+    *   `POST /debug`: Generate and view the structure of prompts and taxonomy data (for debugging, doesn't call OpenAI). Connects to Prod MySQL (taxonomy) and Local PG (prompts, performance).
+    *   `POST /validate`: Validate product data using OpenAI. Connects to Prod MySQL (taxonomy) and Local PG (prompts, performance).
+    *   `GET /test-taxonomy`: Test endpoint to query sample taxonomy data from Prod MySQL.
+
+**3. Analytics (`analytics.js`)**
+    *   `GET /stats`: Get overall business statistics from metrics tables.
+    *   `GET /profit`: Get profit analysis data (by category, over time, top products) from metrics tables.
+    *   `GET /vendors`: Get vendor performance analysis from `vendor_metrics`.
+    *   `GET /stock`: Get stock analysis data (turnover, levels, critical items) from metrics tables.
+    *   `GET /pricing`: Get pricing analysis (price points, elasticity, recommendations) - **uses `orders` table**.
+    *   `GET /categories`: Get category performance analysis (revenue, profit, growth, distribution, trends) - **uses `orders` and `products` tables**.
+    *   `GET /forecast`: (**Likely Obsolete/Broken**) Attempts to get forecast data using MySQL syntax.
+
+**4. Brands Aggregate (`brands-aggregate.js`)**
+    *   `GET /filter-options`: Get distinct brand names and statuses for UI filters (from `brand_metrics`).
+    *   `GET /stats`: Get overall statistics related to brands (from `brand_metrics`).
+    *   `GET /`: List brands with aggregated metrics, supporting filtering, sorting, pagination (from `brand_metrics`).
+
+**5. Categories Aggregate (`categories-aggregate.js`)**
+    *   `GET /filter-options`: Get distinct category types, statuses, and counts for UI filters (from `category_metrics` & `categories`).
+    *   `GET /stats`: Get overall statistics related to categories (from `category_metrics` & `categories`).
+    *   `GET /`: List categories with aggregated metrics, supporting filtering, sorting (incl. hierarchy), pagination (from `category_metrics` & `categories`).
+
+**6. Configuration (`config.js`)**
+    *   **(New)** `GET /global`: Get all global settings.
+    *   **(New)** `PUT /global`: Update global settings.
+    *   **(New)** `GET /products`: List product-specific settings with pagination/search.
+    *   **(New)** `PUT /products/:pid`: Update/Create product-specific settings.
+    *   **(New)** `POST /products/:pid/reset`: Reset product settings to defaults.
+    *   **(New)** `GET /vendors`: List vendor-specific settings with pagination/search.
+    *   **(New)** `PUT /vendors/:vendor`: Update/Create vendor-specific settings.
+    *   **(New)** `POST /vendors/:vendor/reset`: Reset vendor settings to defaults.
+    *   **(Legacy/Obsolete)** `GET /`: Get all config from old single-row tables.
+    *   **(Legacy/Obsolete)** `PUT /stock-thresholds/:id`: Update old stock thresholds.
+    *   **(Legacy/Obsolete)** `PUT /lead-time-thresholds/:id`: Update old lead time thresholds.
+    *   **(Legacy/Obsolete)** `PUT /sales-velocity/:id`: Update old sales velocity config.
+    *   **(Legacy/Obsolete)** `PUT /abc-classification/:id`: Update old ABC config.
+    *   **(Legacy/Obsolete)** `PUT /safety-stock/:id`: Update old safety stock config.
+    *   **(Legacy/Obsolete)** `PUT /turnover/:id`: Update old turnover config.
+
+**7. CSV Operations & Background Tasks (`csv.js`)**
+    *   `GET /:type/progress`: SSE endpoint for full update/reset progress.
+    *   `GET /test`: Simple test endpoint.
+    *   `GET /status`: Check status of the generic background task lock (`activeImport`).
+    *   `GET /calculate-metrics/status`: Check status of metrics calculation.
+    *   `GET /history/import`: Get recent import history.
+    *   `GET /history/calculate`: Get recent metrics calculation history.
+    *   `GET /status/modules`: Get last calculation time per module.
+    *   `GET /status/tables`: Get last sync time per table.
+    *   `GET /status/table-counts`: Get record counts for key tables.
+    *   `POST /update`: (**Potentially Obsolete**) Trigger `update-csv.js` script.
+    *   `POST /import`: Trigger `import-csv.js` script.
+    *   `POST /cancel`: Cancel `/full-update` or `/full-reset` task.
+    *   `POST /reset`: (**Potentially Obsolete**) Trigger `reset-db.js` script.
+    *   `POST /reset-metrics`: Trigger `reset-metrics.js` script.
+    *   `POST /calculate-metrics`: Trigger `calculate-metrics.js` script.
+    *   `POST /import-from-prod`: Trigger `import-from-prod.js` script.
+    *   `POST /full-update`: Trigger `full-update.js` script (preferred update).
+    *   `POST /full-reset`: Trigger `full-reset.js` script (preferred reset).
+
+**8. Dashboard (`dashboard.js`)**
+    *   `GET /stock/metrics`: Get dashboard stock summary metrics & brand breakdown.
+    *   `GET /purchase/metrics`: Get dashboard purchase order summary metrics & vendor breakdown.
+    *   `GET /replenishment/metrics`: Get dashboard replenishment summary & top variants.
+    *   `GET /forecast/metrics`: Get dashboard forecast summary, daily, and category breakdown.
+    *   `GET /overstock/metrics`: Get dashboard overstock summary & category breakdown.
+    *   `GET /overstock/products`: Get list of top overstocked products.
+    *   `GET /best-sellers`: Get dashboard best-selling products, brands, categories - **uses `orders`, `products`**.
+    *   `GET /sales/metrics`: Get dashboard sales summary for a period - **uses `orders`**.
+    *   `GET /low-stock/products`: Get list of top low stock/critical products.
+    *   `GET /trending/products`: Get list of trending products - **uses `orders`, `products`**.
+    *   `GET /vendor/performance`: Get dashboard vendor performance details - **uses `purchase_orders`**.
+    *   `GET /key-metrics`: Get dashboard summary KPIs - **uses multiple base tables**.
+    *   `GET /inventory-health`: Get dashboard inventory health overview - **uses `products`, `product_metrics`**.
+    *   `GET /replenish/products`: Get list of products needing replenishment (overlaps `/low-stock/products`).
+    *   `GET /sales-overview`: Get daily sales totals for chart - **uses `orders`**.
+
+**9. Product Import Utilities (`products-import.js`)**
+    *   `POST /upload-image`: Upload temporary product image, schedule deletion.
+    *   `DELETE /delete-image`: Delete temporary product image.
+    *   `GET /field-options`: Get dropdown options for product fields from Prod MySQL (cached).
+    *   `GET /product-lines/:companyId`: Get product lines for a company from Prod MySQL (cached).
+    *   `GET /sublines/:lineId`: Get sublines for a line from Prod MySQL (cached).
+    *   `GET /check-file/:filename`: Check existence/permissions of uploaded file (temp or reusable).
+    *   `GET /list-uploads`: List files in upload directories.
+    *   `GET /search-products`: Search products in Prod MySQL DB.
+    *   `GET /check-upc-and-generate-sku`: Check UPC existence and generate SKU suggestion based on Prod MySQL data.
+    *   `GET /product-categories/:pid`: Get assigned categories for a product from Prod MySQL.
+
+**10. Product Metrics (`product-metrics.js`)**
+    *   `GET /filter-options`: Get distinct filter values (vendor, brand, abcClass) from `product_metrics`.
+    *   `GET /`: List detailed product metrics with filtering, sorting, pagination (primary data access).
+    *   `GET /:pid`: Get full metrics record for a single product.
+
+**11. Orders (`orders.js`)**
+    *   `GET /`: List orders with summary info, filtering, sorting, pagination, and stats.
+    *   `GET /:orderNumber`: Get details for a single order, including items.
+
+**12. Products (`products.js`)**
+    *   `GET /brands`: Get distinct brands (filtered by PO value).
+    *   `GET /`: List products with core data + metrics, filtering, sorting, pagination.
+    *   `GET /trending`: Get trending products based on `product_metrics`.
+    *   `GET /:id`: Get details for a single product (core data + metrics).
+    *   `POST /import`: (**Likely Obsolete/Dangerous**) Import products from CSV.
+    *   `PUT /:id`: Update core product data.
+    *   `GET /:id/metrics`: (**Redundant**) Get metrics for a single product.
+    *   `GET /:id/time-series`: Get sales/PO history for a single product.
+
+**13. Purchase Orders (`purchase-orders.js`)**
+    *   `GET /`: List purchase orders with summary info, filtering, sorting, pagination, and summary stats.
+    *   `GET /vendor-metrics`: Calculate vendor performance metrics from `purchase_orders`.
+    *   `GET /cost-analysis`: Calculate cost analysis by category from `purchase_orders`.
+    *   `GET /receiving-status`: Get summary counts based on PO receiving status.
+    *   `GET /order-vs-received`: List product ordered vs. received quantities.
+
+**14. Reusable Images (`reusable-images.js`)**
+    *   `GET /`: List all reusable images.
+    *   `GET /by-company/:companyId`: List global and company-specific images.
+    *   `GET /global`: List only global images.
+    *   `GET /:id`: Get a single reusable image record.
+    *   `POST /upload`: Upload a new reusable image and create DB record.
+    *   `PUT /:id`: Update reusable image metadata (name, global, company).
+    *   `DELETE /:id`: Delete reusable image record and file.
+    *   `GET /check-file/:filename`: Check existence/permissions of a reusable image file.
+
+**15. Templates (`templates.js`)**
+    *   `GET /`: List all product data templates.
+    *   `GET /:company/:productType`: Get a specific template.
+    *   `POST /`: Create a new template.
+    *   `PUT /:id`: Update an existing template.
+    *   `DELETE /:id`: Delete a template.
+
+**16. Vendors Aggregate (`vendors-aggregate.js`)**
+    *   `GET /filter-options`: Get distinct vendor names and statuses for UI filters (from `vendor_metrics`).
+    *   `GET /stats`: Get overall statistics related to vendors (from `vendor_metrics` & `purchase_orders`).
+    *   `GET /`: List vendors with aggregated metrics, supporting filtering, sorting, pagination (from `vendor_metrics` & `purchase_orders`).
+
+**Recommendations:**
+
+1.  **Address Obsolete Endpoints:** Prioritize removing or confirming the necessity of the endpoints marked as obsolete/redundant (legacy config, `/analytics/forecast`, `/csv/update`, `/csv/reset`, `/products/import`, `/products/:id/metrics`).
+2.  **Consolidate Overlapping Functionality:** Review the multiple vendor performance and product listing endpoints. Decide on the primary method (e.g., using aggregate tables via `/vendors-aggregate` and `/metrics`) and refactor or remove the others. Clarify the image upload strategies.
+3.  **Standardize Data Access:** Decide whether `dashboard` and `analytics` endpoints should primarily use aggregate tables (like `/metrics`, `/brands-aggregate`, etc.) or if direct access to base tables is sometimes necessary. Aim for consistency and document the reasoning. Optimize queries hitting base tables if they must remain.
+4.  **Improve Background Task Management:** Refactor `csv.js` to use a unified locking mechanism (maybe separate locks per task type?) and a consistent cancellation strategy for all spawned/managed processes. Clarify the purpose of `update` vs `full-update` and `reset` vs `full-reset`.
+5.  **Optimize DB Connections:** Ensure the `getDbConnection` pooling/caching helper from `products-import.js` is used *consistently* across all modules interacting with the production MySQL database (especially `ai_validation.js`). Remove unnecessary tunnel creations.
+6.  **Review Data Integrity:** Double-check the assumptions made (e.g., uniqueness of AI prompts) and ensure database constraints enforce them. Review the `GET /products/brands` filtering logic.
+
+## Changes Made
+
+1. **Removed Obsolete Legacy Endpoints in `config.js`**:
+   - Removed `GET /config/` endpoint
+   - Removed `PUT /config/stock-thresholds/:id` endpoint
+   - Removed `PUT /config/lead-time-thresholds/:id` endpoint
+   - Removed `PUT /config/sales-velocity/:id` endpoint
+   - Removed `PUT /config/abc-classification/:id` endpoint
+   - Removed `PUT /config/safety-stock/:id` endpoint
+   - Removed `PUT /config/turnover/:id` endpoint
+   
+   These endpoints were obsolete as they referenced older, single-row config tables that have been replaced by newer endpoints using the structured tables `settings_global`, `settings_product`, and `settings_vendor`.
+
+2. **Removed MySQL Syntax `/forecast` Endpoint in `analytics.js`**:
+   - Removed `GET /analytics/forecast` endpoint that was using MySQL-specific syntax incompatible with the PostgreSQL database used elsewhere in the application.
+
+3. **Renamed and Removed Redundant Endpoints**:
+   - Renamed `csv.js` to `data-management.js` while maintaining the same `/csv/*` endpoint paths for consistency
+   - Removed deprecated `/csv/update` endpoint (now fully replaced by `/csv/full-update`)
+   - Removed deprecated `/csv/reset` endpoint (now fully replaced by `/csv/full-reset`)
+   - Removed deprecated `/products/import` endpoint (now handled by `/csv/import`)
+   - Removed deprecated `/products/:id/metrics` endpoint (now handled by `/metrics/:pid`)
+
+4. **Fixed Data Integrity Issues**:
+   - Improved `GET /products/brands` endpoint by removing the arbitrary filtering logic that was only showing brands with purchase orders that had a total cost of at least $500
+   - The updated endpoint now returns all distinct brands from visible products, providing more complete data
+
+5. **Optimized Database Connections**:
+   - Created a new `dbConnection.js` utility file that encapsulates the optimized database connection management logic
+   - Improved the `ai-validation.js` file to use this shared connection management, eliminating unnecessary repeated tunnel creation
+   - Added proper connection pooling with timeout-based connection reuse, reducing the overhead of repeatedly creating SSH tunnels
+   - Added query result caching for frequently accessed data to improve performance
+
+These changes improve maintainability by removing duplicate code, enhance consistency by standardizing on the newer endpoint patterns, and optimize performance by reducing redundant database connections.
+
+## Additional Improvements
+
+1. **Further Database Connection Optimizations**:
+   - Extended the use of the optimized database connection utility to additional endpoints in `ai-validation.js`
+   - Updated the `/validate` endpoint and `/test-taxonomy` endpoint to use `getDbConnection`
+   - Ensured consistent connection management across all routes that access the production database
+
+2. **AI Prompts Data Integrity Verification**:
+   - Confirmed proper uniqueness constraints are in place in the database schema for AI prompts
+   - The schema includes:
+     - `unique_company_prompt` constraint ensuring only one prompt per company
+     - `idx_unique_general_prompt` index ensuring only one general prompt in the system
+     - `idx_unique_system_prompt` index ensuring only one system prompt in the system
+   - Endpoint handlers properly handle uniqueness constraint violations with appropriate 409 Conflict responses
+   - Validation ensures company-specific prompts have company IDs, while general/system prompts do not
+
+3. **AI Prompts Endpoint Consolidation**:
+   - Added a new consolidated `/by-type` endpoint that handles all types of prompts (general, system, company_specific)
+   - Marked the existing separate endpoints as deprecated with console warnings
+   - Maintained backward compatibility while providing a cleaner API moving forward
+
+## Completed Items
+
+✅ Removed obsolete legacy endpoints in `config.js`  
+✅ Removed MySQL syntax `/forecast` endpoint in `analytics.js`  
+✅ Fixed `GET /products/brands` endpoint filtering logic  
+✅ Created reusable database connection utility (`dbConnection.js`)  
+✅ Optimized database connections in `ai-validation.js`  
+✅ Verified data integrity in AI prompts handling  
+✅ Consolidated AI prompts endpoints with a unified `/by-type` endpoint  
+
+## Remaining Items
+
+- Consider adding additional error handling and logging for database connections
+- Perform load testing on the optimized database connections to ensure they handle high traffic properly

docs/setup-chat.md

@@ -0,0 +1,23 @@
+This portion of the application is going to be a read only chat archive. It will pull data from a rocketchat export converted to postgresql. This is a separate database than the rest of the inventory application uses, but it will still use users and permissions from the inventory database. Both databases are on the same postgres instance.
+
+For now, let's add a select to the top of the page that allows me to "view as" any of the users in the rocketchat database. We'll connect this to the authorization in the main application later. 
+
+The db connection info is stored in the .env file in the inventory-server root. It contains these variables
+DB_HOST=localhost
+DB_USER=rocketchat_user
+DB_PASSWORD=password
+DB_NAME=rocketchat_converted
+DB_PORT=5432
+
+Not all of the information in this database is relevant as it's a direct export from another app with more features. You can use the query tool to examine the structure and data available.
+
+Server-side files should use similar conventions and the same technologies as the inventory-server (inventor-server root) and auth-server (inventory-server/auth). I will provide my current pm2 ecosystem file upon request for you to add the configuration for the new "chat-server". I use Caddy on the server and can provide my caddyfile to assist with configuring the api routes. All configuration and routes for the chat-server should go in the inventory-server/chat folder or subfolders you create.
+
+The folder you see as inventory-server is actually a direct mount of the /var/www/html/inventory folder on the server. You can read and write files from there like usual, but any terminal commands for the server I will have to run myself.
+
+The "Chat" page should be added to the main application sidebar and a similar page to the others should be created in inventory/src/pages. All other frontend pages should go in inventory/src/components/chat. 
+
+The application uses shadcn components and those should be used for all ui elements where possible (located in inventory/src/components/ui). The UI should match existing pages and components. 
+
+
+

docs/split-up-pos.md

@@ -0,0 +1,112 @@
+Okay, I understand completely now. The core issue is that the previous approaches tried too hard to reconcile every receipt back to a specific PO line within the `purchase_orders` table structure, which doesn't reflect the reality where receipts can be independent events. Your downstream scripts, especially `daily_snapshots` and `product_metrics`, rely on having a complete picture of *all* receivings.
+
+Let's pivot to a model that respects both distinct data streams: **Orders (Intent)** and **Receivings (Actuals)**.
+
+**Proposed Solution: Separate `purchase_orders` and `receivings` Tables**
+
+This is the cleanest way to model the reality you've described.
+
+1.  **`purchase_orders` Table:**
+    *   **Purpose:** Tracks the status and details of purchase *orders* placed. Represents the *intent* to receive goods.
+    *   **Key Columns:** `po_id`, `pid`, `ordered` (quantity ordered), `po_cost_price`, `date` (order/created date), `expected_date`, `status` (PO lifecycle: 'ordered', 'canceled', 'done'), `vendor`, `notes`, etc.
+    *   **Crucially:** This table *does not* need a `received` column or a `receiving_history` column derived from complex allocations. It focuses solely on the PO itself.
+
+2.  **`receivings` Table (New or Refined):**
+    *   **Purpose:** Tracks every single line item received, regardless of whether it was linked to a PO during the receiving process. Represents the *actual* goods that arrived.
+    *   **Key Columns:**
+        *   `receiving_id` (Identifier for the overall receiving document/batch)
+        *   `pid` (Product ID received)
+        *   `received_qty` (Quantity received for this specific line)
+        *   `cost_each` (Actual cost paid for this item on this receiving)
+        *   `received_date` (Actual date the item was received)
+        *   `received_by` (Employee ID/Name)
+        *   `source_po_id` (The `po_id` entered on the receiving screen, *nullable*. Stores the original link attempt, even if it was wrong or missing)
+        *   `source_receiving_status` (The status from the source `receivings` table: 'partial_received', 'full_received', 'paid', 'canceled')
+
+**How the Import Script Changes:**
+
+1.  **Fetch POs:** Fetch data from `po` and `po_products`.
+2.  **Populate `purchase_orders`:**
+    *   Insert/Update rows into `purchase_orders` based directly on the fetched PO data.
+    *   Set `po_id`, `pid`, `ordered`, `po_cost_price`, `date` (`COALESCE(date_ordered, date_created)`), `expected_date`.
+    *   Set `status` by mapping the source `po.status` code directly ('ordered', 'canceled', 'done', etc.).
+    *   **No complex allocation needed here.**
+3.  **Fetch Receivings:** Fetch data from `receivings` and `receivings_products`.
+4.  **Populate `receivings`:**
+    *   For *every* line item fetched from `receivings_products`:
+        *   Perform necessary data validation (dates, numbers).
+        *   Insert a new row into `receivings` with all the relevant details (`receiving_id`, `pid`, `received_qty`, `cost_each`, `received_date`, `received_by`, `source_po_id`, `source_receiving_status`).
+    *   Use `ON CONFLICT (receiving_id, pid)` (or similar unique key based on your source data) `DO UPDATE SET ...` for incremental updates if necessary, or simply delete/re-insert based on `receiving_id` for simplicity if performance allows.
+
+**Impact on Downstream Scripts (and how to adapt):**
+
+*   **Initial Query (Active POs):**
+    *   `SELECT ... FROM purchase_orders po WHERE po.status NOT IN ('canceled', 'done', 'paid_equivalent_status?') AND po.date >= ...`
+    *   `active_pos`: `COUNT(DISTINCT po.po_id)` based on the filtered POs.
+    *   `overdue_pos`: Add `AND po.expected_date < CURRENT_DATE`.
+    *   `total_units`: `SUM(po.ordered)`. Represents total units *ordered* on active POs.
+    *   `total_cost`: `SUM(po.ordered * po.po_cost_price)`. Cost of units *ordered*.
+    *   `total_retail`: `SUM(po.ordered * pm.current_price)`. Retail value of units *ordered*.
+    *   **Result:** This query now cleanly reports on the status of *orders* placed, which seems closer to its original intent. The filter `po.receiving_status NOT IN ('partial_received', 'full_received', 'paid')` is replaced by `po.status NOT IN ('canceled', 'done', 'paid_equivalent?')`. The 90% received check is removed as `received` is not reliably tracked *on the PO* anymore.
+
+*   **`daily_product_snapshots`:**
+    *   **`SalesData` CTE:** No change needed.
+    *   **`ReceivingData` CTE:** **Must be changed.** Query the **`receivings`** table instead of `purchase_orders`.
+        ```sql
+        ReceivingData AS (
+            SELECT
+                rl.pid,
+                COUNT(DISTINCT rl.receiving_id) as receiving_doc_count, 
+                SUM(rl.received_qty) AS units_received,
+                SUM(rl.received_qty * rl.cost_each) AS cost_received
+            FROM public.receivings rl
+            WHERE rl.received_date::date = _date
+              -- Optional: Filter out canceled receivings if needed
+              -- AND rl.source_receiving_status <> 'canceled' 
+            GROUP BY rl.pid
+        ),
+        ```
+    *   **Result:** This now accurately reflects *all* units received on a given day from the definitive source.
+
+*   **`update_product_metrics`:**
+    *   **`CurrentInfo` CTE:** No change needed (pulls from `products`).
+    *   **`OnOrderInfo` CTE:** Needs re-evaluation. How do you want to define "On Order"?
+        *   **Option A (Strict PO View):** `SUM(po.ordered)` from `purchase_orders po WHERE po.status NOT IN ('canceled', 'done', 'paid_equivalent?')`. This is quantity on *open orders*, ignoring fulfillment state. Simple, but might overestimate if items arrived unlinked.
+        *   **Option B (Approximate Fulfillment):** `SUM(po.ordered)` from open POs MINUS `SUM(rl.received_qty)` from `receivings rl` where `rl.source_po_id = po.po_id` (summing only directly linked receivings). Better, but still misses fulfillment via unlinked receivings.
+        *   **Option C (Heuristic):** `SUM(po.ordered)` from open POs MINUS `SUM(rl.received_qty)` from `receivings rl` where `rl.pid = po.pid` and `rl.received_date >= po.date`. This *tries* to account for unlinked receivings but is imprecise.
+        *   **Recommendation:** Start with **Option A** for simplicity, clearly labeling it "Quantity on Open POs". You might need a separate process or metric for a more nuanced view of expected vs. actual pipeline.
+        ```sql
+         -- Example for Option A
+         OnOrderInfo AS (
+             SELECT
+                 pid,
+                 SUM(ordered) AS on_order_qty, -- Total qty on open POs
+                 SUM(ordered * po_cost_price) AS on_order_cost -- Cost of qty on open POs
+             FROM public.purchase_orders
+             WHERE status NOT IN ('canceled', 'done', 'paid_equivalent?') -- Define your open statuses
+             GROUP BY pid
+         ),
+        ```
+    *   **`HistoricalDates` CTE:**
+        *   `date_first_sold`, `max_order_date`: No change (queries `orders`).
+        *   `date_first_received_calc`, `date_last_received_calc`: **Must be changed.** Query `MIN(rl.received_date)` and `MAX(rl.received_date)` from the **`receivings`** table grouped by `pid`.
+    *   **`SnapshotAggregates` CTE:**
+        *   `received_qty_30d`, `received_cost_30d`: These are calculated from `daily_product_snapshots`, which are now correctly sourced from `receivings`, so this part is fine.
+    *   **Forecasting Calculations:** Will use the chosen definition of `on_order_qty`. Be aware of the implications of Option A (potentially inflated if unlinked receivings fulfill orders).
+    *   **Result:** Metrics are calculated based on distinct order data and complete receiving data. The definition of "on order" needs careful consideration.
+
+**Summary of this Approach:**
+
+*   **Pros:**
+    *   Accurately models distinct order and receiving events.
+    *   Provides a definitive source (`receivings`) for all received inventory.
+    *   Simplifies the `purchase_orders` table and its import logic.
+    *   Avoids complex/potentially inaccurate allocation logic for unlinked receivings within the main tables.
+    *   Avoids synthetic records.
+    *   Fixes downstream reporting (`daily_snapshots` receiving data).
+*   **Cons:**
+    *   Requires creating/managing the `receivings` table.
+    *   Requires modifying downstream queries (`ReceivingData`, `OnOrderInfo`, `HistoricalDates`).
+    *   Calculating a precise "net quantity still expected to arrive" (true on-order minus all relevant fulfillment) becomes more complex and may require specific business rules or heuristics outside the basic table structure if Option A for `OnOrderInfo` isn't sufficient.
+
+This two-table approach (`purchase_orders` + `receivings`) seems the most robust and accurate way to handle your requirement for complete receiving records independent of potentially flawed PO linking. It directly addresses the shortcomings of the previous attempts.

ecosystem.config.js

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

inventory-server/auth/add-user.js

@@ -1,103 +0,0 @@
-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/package.json

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

inventory-server/auth/permissions.js

@@ -1,128 +0,0 @@
-// Get pool from global or create a new one if not available
-let pool;
-if (typeof global.pool !== 'undefined') {
-  pool = global.pool;
-} else {
-  // If global pool is not available, create a new connection
-  const { Pool } = require('pg');
-  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,
-  });
-  console.log('Created new database pool in permissions.js');
-}
-
-/**
- * Check if a user has a specific permission
- * @param {number} userId - The user ID to check
- * @param {string} permissionCode - The permission code to check
- * @returns {Promise<boolean>} - Whether the user has the permission
- */
-async function checkPermission(userId, permissionCode) {
-  try {
-    // First check if the user is an admin
-    const adminResult = await pool.query(
-      'SELECT is_admin FROM users WHERE id = $1',
-      [userId]
-    );
-    
-    // If user is admin, automatically grant permission
-    if (adminResult.rows.length > 0 && adminResult.rows[0].is_admin) {
-      return true;
-    }
-    
-    // Otherwise check for specific permission
-    const result = await pool.query(
-      `SELECT COUNT(*) AS has_permission
-       FROM user_permissions up
-       JOIN permissions p ON up.permission_id = p.id
-       WHERE up.user_id = $1 AND p.code = $2`,
-      [userId, permissionCode]
-    );
-    
-    return result.rows[0].has_permission > 0;
-  } catch (error) {
-    console.error('Error checking permission:', error);
-    return false;
-  }
-}
-
-/**
- * Middleware to require a specific permission
- * @param {string} permissionCode - The permission code required
- * @returns {Function} - Express middleware function
- */
-function requirePermission(permissionCode) {
-  return async (req, res, next) => {
-    try {
-      // Check if user is authenticated
-      if (!req.user || !req.user.id) {
-        return res.status(401).json({ error: 'Authentication required' });
-      }
-      
-      const hasPermission = await checkPermission(req.user.id, permissionCode);
-      
-      if (!hasPermission) {
-        return res.status(403).json({ 
-          error: 'Insufficient permissions',
-          requiredPermission: permissionCode
-        });
-      }
-      
-      next();
-    } catch (error) {
-      console.error('Permission middleware error:', error);
-      res.status(500).json({ error: 'Server error checking permissions' });
-    }
-  };
-}
-
-/**
- * Get all permissions for a user
- * @param {number} userId - The user ID
- * @returns {Promise<string[]>} - Array of permission codes
- */
-async function getUserPermissions(userId) {
-  try {
-    // Check if user is admin
-    const adminResult = await pool.query(
-      'SELECT is_admin FROM users WHERE id = $1',
-      [userId]
-    );
-    
-    if (adminResult.rows.length === 0) {
-      return [];
-    }
-    
-    const isAdmin = adminResult.rows[0].is_admin;
-    
-    if (isAdmin) {
-      // Admin gets all permissions
-      const allPermissions = await pool.query('SELECT code FROM permissions');
-      return allPermissions.rows.map(p => p.code);
-    } else {
-      // Get assigned permissions
-      const permissions = await pool.query(
-        `SELECT p.code
-         FROM permissions p
-         JOIN user_permissions up ON p.id = up.permission_id
-         WHERE up.user_id = $1`,
-        [userId]
-      );
-      
-      return permissions.rows.map(p => p.code);
-    }
-  } catch (error) {
-    console.error('Error getting user permissions:', error);
-    return [];
-  }
-}
-
-module.exports = {
-  checkPermission,
-  requirePermission,
-  getUserPermissions
-}; 

inventory-server/auth/routes.js

@@ -1,513 +0,0 @@
-const express = require('express');
-const router = express.Router();
-const bcrypt = require('bcrypt');
-const jwt = require('jsonwebtoken');
-const { requirePermission, getUserPermissions } = require('./permissions');
-
-// Get pool from global or create a new one if not available
-let pool;
-if (typeof global.pool !== 'undefined') {
-  pool = global.pool;
-} else {
-  // If global pool is not available, create a new connection
-  const { Pool } = require('pg');
-  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,
-  });
-  console.log('Created new database pool in routes.js');
-}
-
-// Authentication middleware
-const authenticate = async (req, res, next) => {
-  try {
-    const authHeader = req.headers.authorization;
-    if (!authHeader || !authHeader.startsWith('Bearer ')) {
-      return res.status(401).json({ error: 'Authentication required' });
-    }
-
-    const token = authHeader.split(' ')[1];
-    const decoded = jwt.verify(token, process.env.JWT_SECRET);
-    
-    // Get user from database
-    const result = await pool.query(
-      'SELECT id, username, is_admin FROM users WHERE id = $1',
-      [decoded.userId]
-    );
-    
-    if (result.rows.length === 0) {
-      return res.status(401).json({ error: 'User not found' });
-    }
-    
-    // Attach user to request
-    req.user = result.rows[0];
-    next();
-  } catch (error) {
-    console.error('Authentication error:', error);
-    res.status(401).json({ error: 'Invalid token' });
-  }
-};
-
-// Login route
-router.post('/login', async (req, res) => {
-  try {
-    const { username, password } = req.body;
-    
-    // Get user from database
-    const result = await pool.query(
-      'SELECT id, username, password, is_admin, is_active FROM users WHERE username = $1',
-      [username]
-    );
-    
-    if (result.rows.length === 0) {
-      return res.status(401).json({ error: 'Invalid username or password' });
-    }
-    
-    const user = result.rows[0];
-    
-    // Check if user is active
-    if (!user.is_active) {
-      return res.status(403).json({ error: 'Account is inactive' });
-    }
-    
-    // Verify password
-    const validPassword = await bcrypt.compare(password, user.password);
-    if (!validPassword) {
-      return res.status(401).json({ error: 'Invalid username or password' });
-    }
-    
-    // Update last login
-    await pool.query(
-      'UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = $1',
-      [user.id]
-    );
-    
-    // Generate JWT
-    const token = jwt.sign(
-      { userId: user.id, username: user.username },
-      process.env.JWT_SECRET,
-      { expiresIn: '8h' }
-    );
-    
-    // Get user permissions
-    const permissions = await getUserPermissions(user.id);
-    
-    res.json({
-      token,
-      user: {
-        id: user.id,
-        username: user.username,
-        is_admin: user.is_admin,
-        permissions
-      }
-    });
-  } catch (error) {
-    console.error('Login error:', error);
-    res.status(500).json({ error: 'Server error' });
-  }
-});
-
-// Get current user
-router.get('/me', authenticate, async (req, res) => {
-  try {
-    // Get user permissions
-    const permissions = await getUserPermissions(req.user.id);
-    
-    res.json({
-      id: req.user.id,
-      username: req.user.username,
-      is_admin: req.user.is_admin,
-      permissions
-    });
-  } catch (error) {
-    console.error('Error getting current user:', error);
-    res.status(500).json({ error: 'Server error' });
-  }
-});
-
-// Get all users
-router.get('/users', authenticate, requirePermission('view:users'), async (req, res) => {
-  try {
-    const result = await pool.query(`
-      SELECT id, username, email, is_admin, is_active, created_at, last_login
-      FROM users
-      ORDER BY username
-    `);
-    
-    res.json(result.rows);
-  } catch (error) {
-    console.error('Error getting users:', error);
-    res.status(500).json({ error: 'Server error' });
-  }
-});
-
-// Get user with permissions
-router.get('/users/:id', authenticate, requirePermission('view:users'), async (req, res) => {
-  try {
-    const userId = req.params.id;
-    
-    // Get user details
-    const userResult = await pool.query(`
-      SELECT id, username, email, is_admin, is_active, created_at, last_login
-      FROM users
-      WHERE id = $1
-    `, [userId]);
-    
-    if (userResult.rows.length === 0) {
-      return res.status(404).json({ error: 'User not found' });
-    }
-    
-    // Get user permissions
-    const permissionsResult = await pool.query(`
-      SELECT p.id, p.name, p.code, p.category, p.description
-      FROM permissions p
-      JOIN user_permissions up ON p.id = up.permission_id
-      WHERE up.user_id = $1
-      ORDER BY p.category, p.name
-    `, [userId]);
-    
-    // Combine user and permissions
-    const user = {
-      ...userResult.rows[0],
-      permissions: permissionsResult.rows
-    };
-    
-    res.json(user);
-  } catch (error) {
-    console.error('Error getting user:', error);
-    res.status(500).json({ error: 'Server error' });
-  }
-});
-
-// Create new user
-router.post('/users', authenticate, requirePermission('create:users'), async (req, res) => {
-  const client = await pool.connect();
-  
-  try {
-    const { username, email, password, is_admin, is_active, permissions } = req.body;
-    
-    console.log("Create user request:", {
-      username,
-      email,
-      is_admin,
-      is_active,
-      permissions: permissions || []
-    });
-    
-    // Validate required fields
-    if (!username || !password) {
-      return res.status(400).json({ error: 'Username and password are required' });
-    }
-    
-    // Check if username is taken
-    const existingUser = await client.query(
-      'SELECT id FROM users WHERE username = $1',
-      [username]
-    );
-    
-    if (existingUser.rows.length > 0) {
-      return res.status(400).json({ error: 'Username already exists' });
-    }
-    
-    // Start transaction
-    await client.query('BEGIN');
-    
-    // Hash password
-    const saltRounds = 10;
-    const hashedPassword = await bcrypt.hash(password, saltRounds);
-    
-    // Insert new user
-    const userResult = await client.query(`
-      INSERT INTO users (username, email, password, is_admin, is_active, created_at)
-      VALUES ($1, $2, $3, $4, $5, CURRENT_TIMESTAMP)
-      RETURNING id
-    `, [username, email || null, hashedPassword, !!is_admin, is_active !== false]);
-    
-    const userId = userResult.rows[0].id;
-    
-    // Assign permissions if provided and not admin
-    if (!is_admin && Array.isArray(permissions) && permissions.length > 0) {
-      console.log("Adding permissions for new user:", userId);
-      console.log("Permissions received:", permissions);
-      
-      // Check permission format
-      const permissionIds = permissions.map(p => {
-        if (typeof p === 'object' && p.id) {
-          console.log("Permission is an object with ID:", p.id);
-          return parseInt(p.id, 10);
-        } else if (typeof p === 'number') {
-          console.log("Permission is a number:", p);
-          return p;
-        } else if (typeof p === 'string' && !isNaN(parseInt(p, 10))) {
-          console.log("Permission is a string that can be parsed as a number:", p);
-          return parseInt(p, 10);
-        } else {
-          console.log("Unknown permission format:", typeof p, p);
-          // If it's a permission code, we need to look up the ID
-          return null;
-        }
-      }).filter(id => id !== null);
-      
-      console.log("Filtered permission IDs:", permissionIds);
-      
-      if (permissionIds.length > 0) {
-        const permissionValues = permissionIds
-          .map(permId => `(${userId}, ${permId})`)
-          .join(',');
-        
-        console.log("Inserting permission values:", permissionValues);
-        
-        try {
-          await client.query(`
-            INSERT INTO user_permissions (user_id, permission_id)
-            VALUES ${permissionValues}
-            ON CONFLICT DO NOTHING
-          `);
-          console.log("Successfully inserted permissions for new user:", userId);
-        } catch (err) {
-          console.error("Error inserting permissions for new user:", err);
-          throw err;
-        }
-      } else {
-        console.log("No valid permission IDs found to insert for new user");
-      }
-    } else {
-      console.log("Not adding permissions: is_admin =", is_admin, "permissions array:", Array.isArray(permissions), "length:", permissions ? permissions.length : 0);
-    }
-    
-    await client.query('COMMIT');
-    
-    res.status(201).json({ 
-      id: userId, 
-      message: 'User created successfully' 
-    });
-  } catch (error) {
-    await client.query('ROLLBACK');
-    console.error('Error creating user:', error);
-    res.status(500).json({ error: 'Server error' });
-  } finally {
-    client.release();
-  }
-});
-
-// Update user
-router.put('/users/:id', authenticate, requirePermission('edit:users'), async (req, res) => {
-  const client = await pool.connect();
-  
-  try {
-    const userId = req.params.id;
-    const { username, email, password, is_admin, is_active, permissions } = req.body;
-    
-    console.log("Update user request:", {
-      userId,
-      username,
-      email,
-      is_admin,
-      is_active,
-      permissions: permissions || []
-    });
-    
-    // Check if user exists
-    const userExists = await client.query(
-      'SELECT id FROM users WHERE id = $1',
-      [userId]
-    );
-    
-    if (userExists.rows.length === 0) {
-      return res.status(404).json({ error: 'User not found' });
-    }
-    
-    // Start transaction
-    await client.query('BEGIN');
-    
-    // Build update fields
-    const updateFields = [];
-    const updateValues = [userId]; // First parameter is the user ID
-    let paramIndex = 2;
-    
-    if (username !== undefined) {
-      updateFields.push(`username = $${paramIndex++}`);
-      updateValues.push(username);
-    }
-    
-    if (email !== undefined) {
-      updateFields.push(`email = $${paramIndex++}`);
-      updateValues.push(email || null);
-    }
-    
-    if (is_admin !== undefined) {
-      updateFields.push(`is_admin = $${paramIndex++}`);
-      updateValues.push(!!is_admin);
-    }
-    
-    if (is_active !== undefined) {
-      updateFields.push(`is_active = $${paramIndex++}`);
-      updateValues.push(!!is_active);
-    }
-    
-    // Update password if provided
-    if (password) {
-      const saltRounds = 10;
-      const hashedPassword = await bcrypt.hash(password, saltRounds);
-      updateFields.push(`password = $${paramIndex++}`);
-      updateValues.push(hashedPassword);
-    }
-    
-    // Update user if there are fields to update
-    if (updateFields.length > 0) {
-      updateFields.push(`updated_at = CURRENT_TIMESTAMP`);
-      
-      await client.query(`
-        UPDATE users
-        SET ${updateFields.join(', ')}
-        WHERE id = $1
-      `, updateValues);
-    }
-    
-    // Update permissions if provided
-    if (Array.isArray(permissions)) {
-      console.log("Updating permissions for user:", userId);
-      console.log("Permissions received:", permissions);
-      
-      // First remove existing permissions
-      await client.query(
-        'DELETE FROM user_permissions WHERE user_id = $1',
-        [userId]
-      );
-      console.log("Deleted existing permissions for user:", userId);
-      
-      // Add new permissions if any and not admin
-      const newIsAdmin = is_admin !== undefined ? is_admin : (await client.query('SELECT is_admin FROM users WHERE id = $1', [userId])).rows[0].is_admin;
-      
-      console.log("User is admin:", newIsAdmin);
-      
-      if (!newIsAdmin && permissions.length > 0) {
-        console.log("Adding permissions:", permissions);
-        
-        // Check permission format
-        const permissionIds = permissions.map(p => {
-          if (typeof p === 'object' && p.id) {
-            console.log("Permission is an object with ID:", p.id);
-            return parseInt(p.id, 10);
-          } else if (typeof p === 'number') {
-            console.log("Permission is a number:", p);
-            return p;
-          } else if (typeof p === 'string' && !isNaN(parseInt(p, 10))) {
-            console.log("Permission is a string that can be parsed as a number:", p);
-            return parseInt(p, 10);
-          } else {
-            console.log("Unknown permission format:", typeof p, p);
-            // If it's a permission code, we need to look up the ID
-            return null;
-          }
-        }).filter(id => id !== null);
-        
-        console.log("Filtered permission IDs:", permissionIds);
-        
-        if (permissionIds.length > 0) {
-          const permissionValues = permissionIds
-            .map(permId => `(${userId}, ${permId})`)
-            .join(',');
-          
-          console.log("Inserting permission values:", permissionValues);
-          
-          try {
-            await client.query(`
-              INSERT INTO user_permissions (user_id, permission_id)
-              VALUES ${permissionValues}
-              ON CONFLICT DO NOTHING
-            `);
-            console.log("Successfully inserted permissions for user:", userId);
-          } catch (err) {
-            console.error("Error inserting permissions:", err);
-            throw err;
-          }
-        } else {
-          console.log("No valid permission IDs found to insert");
-        }
-      }
-    }
-    
-    await client.query('COMMIT');
-    
-    res.json({ message: 'User updated successfully' });
-  } catch (error) {
-    await client.query('ROLLBACK');
-    console.error('Error updating user:', error);
-    res.status(500).json({ error: 'Server error' });
-  } finally {
-    client.release();
-  }
-});
-
-// Delete user
-router.delete('/users/:id', authenticate, requirePermission('delete:users'), async (req, res) => {
-  try {
-    const userId = req.params.id;
-    
-    // Check that user is not deleting themselves
-    if (req.user.id === parseInt(userId, 10)) {
-      return res.status(400).json({ error: 'Cannot delete your own account' });
-    }
-    
-    // Delete user (this will cascade to user_permissions due to FK constraints)
-    const result = await pool.query(
-      'DELETE FROM users WHERE id = $1 RETURNING id',
-      [userId]
-    );
-    
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'User not found' });
-    }
-    
-    res.json({ message: 'User deleted successfully' });
-  } catch (error) {
-    console.error('Error deleting user:', error);
-    res.status(500).json({ error: 'Server error' });
-  }
-});
-
-// Get all permissions grouped by category
-router.get('/permissions/categories', authenticate, requirePermission('view:users'), async (req, res) => {
-  try {
-    const result = await pool.query(`
-      SELECT category, json_agg(
-        json_build_object(
-          'id', id,
-          'name', name,
-          'code', code,
-          'description', description
-        ) ORDER BY name
-      ) as permissions
-      FROM permissions
-      GROUP BY category
-      ORDER BY category
-    `);
-    
-    res.json(result.rows);
-  } catch (error) {
-    console.error('Error getting permissions:', error);
-    res.status(500).json({ error: 'Server error' });
-  }
-});
-
-// Get all permissions
-router.get('/permissions', authenticate, requirePermission('view:users'), async (req, res) => {
-  try {
-    const result = await pool.query(`
-      SELECT *
-      FROM permissions
-      ORDER BY category, name
-    `);
-    
-    res.json(result.rows);
-  } catch (error) {
-    console.error('Error getting permissions:', error);
-    res.status(500).json({ error: 'Server error' });
-  }
-});
-
-module.exports = router; 

inventory-server/auth/schema.sql

@@ -1,89 +0,0 @@
-CREATE TABLE users (
-  id SERIAL PRIMARY KEY,
-  username VARCHAR(255) NOT NULL UNIQUE,
-  password VARCHAR(255) NOT NULL,
-  email VARCHAR UNIQUE,
-  is_admin BOOLEAN DEFAULT FALSE,
-  is_active BOOLEAN DEFAULT TRUE,
-  last_login TIMESTAMP WITH TIME ZONE,
-  updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-  created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-); 
-
--- 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';
-
--- Sequence and defined type for users table if not exists
-CREATE SEQUENCE IF NOT EXISTS users_id_seq;
-
--- Create permissions table
-CREATE TABLE IF NOT EXISTS "public"."permissions" (
-    "id" SERIAL PRIMARY KEY,
-    "name" varchar NOT NULL UNIQUE,
-    "code" varchar NOT NULL UNIQUE,
-    "description" text,
-    "category" varchar NOT NULL,
-    "created_at" timestamp with time zone DEFAULT CURRENT_TIMESTAMP,
-    "updated_at" timestamp with time zone DEFAULT CURRENT_TIMESTAMP
-);
-
--- Create user_permissions junction table
-CREATE TABLE IF NOT EXISTS "public"."user_permissions" (
-    "user_id" int4 NOT NULL REFERENCES "public"."users"("id") ON DELETE CASCADE,
-    "permission_id" int4 NOT NULL REFERENCES "public"."permissions"("id") ON DELETE CASCADE,
-    "created_at" timestamp with time zone DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY ("user_id", "permission_id")
-);
-
--- Add triggers for updated_at on users and permissions
-DROP TRIGGER IF EXISTS update_users_updated_at ON users;
-CREATE TRIGGER update_users_updated_at
-    BEFORE UPDATE ON users
-    FOR EACH ROW
-    EXECUTE FUNCTION update_updated_at_column();
-
-DROP TRIGGER IF EXISTS update_permissions_updated_at ON permissions;
-CREATE TRIGGER update_permissions_updated_at
-    BEFORE UPDATE ON permissions
-    FOR EACH ROW
-    EXECUTE FUNCTION update_updated_at_column();
-
--- Insert default permissions by page - only the ones used in application
-INSERT INTO permissions (name, code, description, category) VALUES 
-    ('Dashboard Access', 'access:dashboard', 'Can access the Dashboard page', 'Pages'),
-    ('Products Access', 'access:products', 'Can access the Products page', 'Pages'),
-    ('Categories Access', 'access:categories', 'Can access the Categories page', 'Pages'),
-    ('Vendors Access', 'access:vendors', 'Can access the Vendors page', 'Pages'),
-    ('Analytics Access', 'access:analytics', 'Can access the Analytics page', 'Pages'),
-    ('Forecasting Access', 'access:forecasting', 'Can access the Forecasting page', 'Pages'),
-    ('Purchase Orders Access', 'access:purchase_orders', 'Can access the Purchase Orders page', 'Pages'),
-    ('Import Access', 'access:import', 'Can access the Import page', 'Pages'),
-    ('Settings Access', 'access:settings', 'Can access the Settings page', 'Pages'),
-    ('AI Validation Debug Access', 'access:ai_validation_debug', 'Can access the AI Validation Debug page', 'Pages')
-ON CONFLICT (code) DO NOTHING;
-
--- Settings section permissions
-INSERT INTO permissions (name, code, description, category) VALUES
-    ('Data Management', 'settings:data_management', 'Access to the Data Management settings section', 'Settings'),
-    ('Stock Management', 'settings:stock_management', 'Access to the Stock Management settings section', 'Settings'),
-    ('Performance Metrics', 'settings:performance_metrics', 'Access to the Performance Metrics settings section', 'Settings'),
-    ('Calculation Settings', 'settings:calculation_settings', 'Access to the Calculation Settings section', 'Settings'),
-    ('Template Management', 'settings:templates', 'Access to the Template Management settings section', 'Settings'),
-    ('User Management', 'settings:user_management', 'Access to the User Management settings section', 'Settings')
-ON CONFLICT (code) DO NOTHING;
-
--- Set any existing users as admin
-UPDATE users SET is_admin = TRUE WHERE is_admin IS NULL;
-
--- Grant all permissions to admin users
-INSERT INTO user_permissions (user_id, permission_id)
-SELECT u.id, p.id
-FROM users u, permissions p
-WHERE u.is_admin = TRUE
-ON CONFLICT DO NOTHING; 

inventory-server/auth/server.js

@@ -35,7 +35,7 @@ global.pool = pool;
 app.use(express.json());
 app.use(morgan('combined'));
 app.use(cors({
-  origin: ['http://localhost:5173', 'http://localhost:5174', 'https://inventory.kent.pw'],
+  origin: ['http://localhost:5175', 'http://localhost:5174', 'https://inventory.kent.pw', 'https://tools.acherryontop.com', 'https://tools.acherryontop.com'],
   credentials: true
 }));
 
@@ -62,6 +62,12 @@ app.post('/login', async (req, res) => {
       return res.status(403).json({ error: 'Account is inactive' });
     }
 
+    // Update last login timestamp
+    await pool.query(
+      'UPDATE users SET last_login = CURRENT_TIMESTAMP WHERE id = $1',
+      [user.id]
+    );
+
     // Generate JWT token
     const token = jwt.sign(
       { userId: user.id, username: user.username },
@@ -76,7 +82,7 @@ app.post('/login', async (req, res) => {
       JOIN user_permissions up ON p.id = up.permission_id
       WHERE up.user_id = $1
     `, [user.id]);
-    
+
     const permissions = permissionsResult.rows.map(row => row.code);
 
     res.json({ 
@@ -108,7 +114,7 @@ app.get('/me', async (req, res) => {
     
     // Get user details from database
     const userResult = await pool.query(
-      'SELECT id, username, email, is_admin, is_active FROM users WHERE id = $1',
+      'SELECT id, username, email, is_admin, rocket_chat_user_id, is_active FROM users WHERE id = $1',
       [decoded.userId]
     );
     
@@ -135,6 +141,7 @@ app.get('/me', async (req, res) => {
       id: user.id,
       username: user.username,
       email: user.email,
+      rocket_chat_user_id: user.rocket_chat_user_id,
       is_admin: user.is_admin,
       permissions: permissions
     });

inventory-server/chat/server.js

@@ -0,0 +1,83 @@
+require('dotenv').config({ path: '../.env' });
+const express = require('express');
+const cors = require('cors');
+const { Pool } = require('pg');
+const morgan = require('morgan');
+const chatRoutes = require('./routes');
+
+// Log startup configuration
+console.log('Starting chat server with config:', {
+  host: process.env.CHAT_DB_HOST,
+  user: process.env.CHAT_DB_USER,
+  database: process.env.CHAT_DB_NAME || 'rocketchat_converted',
+  port: process.env.CHAT_DB_PORT,
+  chat_port: process.env.CHAT_PORT || 3014
+});
+
+const app = express();
+const port = process.env.CHAT_PORT || 3014;
+
+// Database configuration for rocketchat_converted database
+const pool = new Pool({
+  host: process.env.CHAT_DB_HOST,
+  user: process.env.CHAT_DB_USER,
+  password: process.env.CHAT_DB_PASSWORD,
+  database: process.env.CHAT_DB_NAME || 'rocketchat_converted',
+  port: process.env.CHAT_DB_PORT,
+});
+
+// Make pool available globally
+global.pool = pool;
+
+// Middleware
+app.use(express.json());
+app.use(morgan('combined'));
+app.use(cors({
+  origin: ['http://localhost:5175', 'http://localhost:5174', 'https://inventory.kent.pw', 'https://tools.acherryontop.com', 'https://tools.acherryontop.com'],
+  credentials: true
+}));
+
+// Test database connection endpoint
+app.get('/test-db', async (req, res) => {
+  try {
+    const result = await pool.query('SELECT COUNT(*) as user_count FROM users WHERE active = true');
+    const messageResult = await pool.query('SELECT COUNT(*) as message_count FROM message');
+    const roomResult = await pool.query('SELECT COUNT(*) as room_count FROM room');
+    
+    res.json({
+      status: 'success',
+      database: 'rocketchat_converted',
+      stats: {
+        active_users: parseInt(result.rows[0].user_count),
+        total_messages: parseInt(messageResult.rows[0].message_count),
+        total_rooms: parseInt(roomResult.rows[0].room_count)
+      }
+    });
+  } catch (error) {
+    console.error('Database test error:', error);
+    res.status(500).json({ 
+      status: 'error',
+      error: 'Database connection failed',
+      details: error.message
+    });
+  }
+});
+
+// Mount all routes from routes.js
+app.use('/', chatRoutes);
+
+// 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(`Chat server running on port ${port}`);
+}); 

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

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

inventory-server/db/config-schema.sql

@@ -1,278 +0,0 @@
--- 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 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 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 (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 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 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 (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 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 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 (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 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 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 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 INTEGER NOT NULL DEFAULT 14,
-    service_level DECIMAL(5,2) NOT NULL DEFAULT 95.0,
-    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 (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 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 INTEGER NOT NULL DEFAULT 30,
-    target_rate DECIMAL(10,2) NOT NULL DEFAULT 1.0,
-    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 (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 sales_seasonality (
-    month INTEGER NOT NULL,
-    seasonality_factor DECIMAL(5,3) DEFAULT 0,
-    last_updated TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    PRIMARY KEY (month),
-    CONSTRAINT month_range CHECK (month BETWEEN 1 AND 12),
-    CONSTRAINT seasonality_range CHECK (seasonality_factor BETWEEN -1.0 AND 1.0)
-);
-
-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 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 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 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 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 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 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 CONFLICT (month) DO UPDATE SET
-    last_updated = CURRENT_TIMESTAMP;
-
--- View to show thresholds with category names
-CREATE OR REPLACE VIEW stock_thresholds_view AS
-SELECT 
-    st.*,
-    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 '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
-LEFT JOIN 
-    categories c ON st.category_id = c.cat_id
-ORDER BY 
-    CASE 
-        WHEN st.category_id IS NULL AND st.vendor IS NULL THEN 1
-        WHEN st.category_id IS NULL THEN 2
-        WHEN st.vendor IS NULL THEN 3
-        ELSE 4
-    END,
-    c.name,
-    st.vendor;
-
--- History and status tables
-CREATE TABLE IF NOT EXISTS calculate_history (
-    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 JSONB
-);
-
-CREATE TABLE IF NOT EXISTS calculate_status (
-    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 WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    last_sync_id BIGINT
-);
-
-CREATE TABLE IF NOT EXISTS import_history (
-    id BIGSERIAL PRIMARY KEY,
-    table_name VARCHAR(50) NOT NULL,
-    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 calculation_status DEFAULT 'running',
-    error_message TEXT,
-    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,375 +0,0 @@
--- Disable foreign key checks
-SET session_replication_role = 'replica';
-
--- Temporary tables for batch metrics processing
-CREATE TABLE temp_sales_metrics (
-    pid BIGINT NOT NULL,
-    daily_sales_avg DECIMAL(10,3),
-    weekly_sales_avg DECIMAL(10,3),
-    monthly_sales_avg DECIMAL(10,3),
-    total_revenue DECIMAL(10,3),
-    avg_margin_percent DECIMAL(10,3),
-    first_sale_date DATE,
-    last_sale_date DATE,
-    PRIMARY KEY (pid)
-);
-
-CREATE TABLE temp_purchase_metrics (
-    pid BIGINT NOT NULL,
-    avg_lead_time_days INTEGER,
-    last_purchase_date DATE,
-    first_received_date DATE,
-    last_received_date DATE,
-    PRIMARY KEY (pid)
-);
-
--- New table for product metrics
-CREATE TABLE product_metrics (
-    pid BIGINT NOT NULL,
-    last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    -- Sales velocity metrics
-    daily_sales_avg DECIMAL(10,3),
-    weekly_sales_avg DECIMAL(10,3),
-    monthly_sales_avg DECIMAL(10,3),
-    avg_quantity_per_order DECIMAL(10,3),
-    number_of_orders INTEGER,
-    first_sale_date DATE,
-    last_sale_date DATE,
-    -- Stock metrics
-    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),
-    inventory_value DECIMAL(10,3),
-    cost_of_goods_sold DECIMAL(10,3),
-    gross_profit DECIMAL(10,3),
-    gmroi DECIMAL(10,3),
-    -- Purchase metrics
-    avg_lead_time_days INTEGER,
-    last_purchase_date DATE,
-    first_received_date DATE,
-    last_received_date DATE,
-    -- Classification metrics
-    abc_class CHAR(1),
-    stock_status VARCHAR(20),
-    -- Turnover metrics
-    turnover_rate DECIMAL(12,3),
-    -- Lead time metrics
-    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
-);
-
-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 product_time_aggregates (
-    pid BIGINT NOT NULL,
-    year INTEGER NOT NULL,
-    month INTEGER NOT NULL,
-    -- Sales metrics
-    total_quantity_sold INTEGER DEFAULT 0,
-    total_revenue DECIMAL(10,3) DEFAULT 0,
-    total_cost DECIMAL(10,3) DEFAULT 0,
-    order_count INTEGER DEFAULT 0,
-    -- Stock changes
-    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
-);
-
-CREATE INDEX idx_date ON product_time_aggregates(year, month);
-
--- Create vendor_details table
-CREATE TABLE vendor_details (
-    vendor VARCHAR(100) PRIMARY KEY,
-    contact_name VARCHAR(100),
-    email VARCHAR(255),
-    phone VARCHAR(50),
-    status VARCHAR(20) DEFAULT 'active',
-    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
-);
-
-CREATE INDEX idx_vendor_details_status ON vendor_details(status);
-
--- New table for 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 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 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
-);
-
-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 category_metrics (
-    category_id BIGINT NOT NULL,
-    last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    -- Product metrics
-    product_count INTEGER DEFAULT 0,
-    active_products INTEGER DEFAULT 0,
-    -- Financial metrics
-    total_value DECIMAL(15,3) DEFAULT 0,
-    avg_margin DECIMAL(5,2),
-    turnover_rate DECIMAL(12,3),
-    growth_rate DECIMAL(5,2),
-    -- Status
-    status VARCHAR(20) DEFAULT 'active',
-    PRIMARY KEY (category_id),
-    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 vendor_time_metrics (
-    vendor VARCHAR(100) NOT NULL,
-    year INTEGER NOT NULL,
-    month INTEGER NOT NULL,
-    -- Order metrics
-    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
-);
-
-CREATE INDEX idx_vendor_date ON vendor_time_metrics(year, month);
-
--- New table for category time-based metrics
-CREATE TABLE category_time_metrics (
-    category_id BIGINT NOT NULL,
-    year INTEGER NOT NULL,
-    month INTEGER NOT NULL,
-    -- Product metrics
-    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
-);
-
-CREATE INDEX idx_category_date ON category_time_metrics(year, month);
-
--- New table for category-based 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 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
-);
-
-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 brand_metrics (
-    brand VARCHAR(100) NOT NULL,
-    last_calculated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    -- Product metrics
-    product_count INTEGER DEFAULT 0,
-    active_products INTEGER DEFAULT 0,
-    -- Stock metrics
-    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)
-);
-
-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 brand_time_metrics (
-    brand VARCHAR(100) NOT NULL,
-    year INTEGER NOT NULL,
-    month INTEGER NOT NULL,
-    -- Product metrics
-    product_count INTEGER DEFAULT 0,
-    active_products INTEGER DEFAULT 0,
-    -- Stock metrics
-    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, year, month)
-);
-
-CREATE INDEX idx_brand_time_date ON brand_time_metrics(year, month);
-
--- New table for sales forecasts
-CREATE TABLE sales_forecasts (
-    pid BIGINT NOT NULL,
-    forecast_date DATE NOT NULL,
-    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
-);
-
-CREATE INDEX idx_forecast_date ON sales_forecasts(forecast_date);
-
--- New table for category forecasts
-CREATE TABLE category_forecasts (
-    category_id BIGINT NOT NULL,
-    forecast_date DATE NOT NULL,
-    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
-);
-
-CREATE INDEX idx_cat_forecast_date ON category_forecasts(forecast_date);
-
--- Create views for common calculations
-CREATE OR REPLACE VIEW inventory_health AS
-WITH stock_levels AS (
-    SELECT 
-        p.pid,
-        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 
-    *,
-    CASE 
-        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 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 
-    *,
-    CASE 
-        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;
-
-SET session_replication_role = 'origin';

inventory-server/db/schema.sql

@@ -1,211 +0,0 @@
--- Enable strict error reporting
-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
-    -- Check which table is being updated and use the appropriate column
-    IF TG_TABLE_NAME = 'categories' THEN
-        NEW.updated_at = CURRENT_TIMESTAMP;
-    ELSE
-        NEW.updated = CURRENT_TIMESTAMP;
-    END IF;
-    RETURN NEW;
-END;
-$func$ language plpgsql;
-
--- Create tables
-CREATE TABLE products (
-    pid BIGINT NOT NULL,
-    title VARCHAR(255) NOT NULL,
-    description TEXT,
-    SKU VARCHAR(50) NOT NULL,
-    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 WITH TIME ZONE,
-    visible BOOLEAN DEFAULT true,
-    managing_stock BOOLEAN DEFAULT true,
-    replenishable BOOLEAN DEFAULT true,
-    vendor VARCHAR(100),
-    vendor_reference VARCHAR(100),
-    notions_reference VARCHAR(100),
-    permalink VARCHAR(255),
-    categories TEXT,
-    image VARCHAR(255),
-    image_175 VARCHAR(255),
-    image_full VARCHAR(255),
-    brand VARCHAR(100),
-    line VARCHAR(100),
-    subline VARCHAR(100),
-    artist VARCHAR(100),
-    options TEXT,
-    tags TEXT,
-    moq INTEGER DEFAULT 1,
-    uom INTEGER DEFAULT 1,
-    rating DECIMAL(10,2) DEFAULT 0.00,
-    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 INTEGER DEFAULT 0,
-    baskets INTEGER DEFAULT 0,
-    notifies INTEGER DEFAULT 0,
-    date_last_sold DATE,
-    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,
-    parent_id BIGINT,
-    description TEXT,
-    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)
-);
-
--- 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 (
-    cat_id BIGINT NOT NULL,
-    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
-);
-
-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 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 INTEGER NOT NULL,
-    discount DECIMAL(10,3) DEFAULT 0.000,
-    tax DECIMAL(10,3) DEFAULT 0.000,
-    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 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 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(255) NOT NULL,
-    cost_price DECIMAL(10, 3) NOT NULL,
-    po_cost_price DECIMAL(10, 3) NOT NULL,
-    status SMALLINT DEFAULT 1,
-    receiving_status SMALLINT DEFAULT 1,
-    notes TEXT,
-    long_note TEXT,
-    ordered INTEGER NOT NULL,
-    received INTEGER DEFAULT 0,
-    received_date DATE,
-    last_received_date DATE,
-    received_by VARCHAR,
-    receiving_history JSONB,
-    updated TIMESTAMP WITH TIME ZONE NOT NULL DEFAULT CURRENT_TIMESTAMP,
-    FOREIGN KEY (pid) REFERENCES products(pid),
-    UNIQUE (po_id, pid)
-);
-
--- 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

@@ -1,115 +0,0 @@
--- 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 Prompts table for storing validation prompts
-CREATE TABLE IF NOT EXISTS ai_prompts (
-    id SERIAL PRIMARY KEY,
-    prompt_text TEXT NOT NULL,
-    prompt_type TEXT NOT NULL CHECK (prompt_type IN ('general', 'company_specific', 'system')),
-    company TEXT,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    CONSTRAINT unique_company_prompt UNIQUE (company),
-    CONSTRAINT company_required_for_specific CHECK (
-        (prompt_type = 'general' AND company IS NULL) OR 
-        (prompt_type = 'system' AND company IS NULL) OR 
-        (prompt_type = 'company_specific' AND company IS NOT NULL)
-    )
-);
-
--- Create a unique partial index to ensure only one general prompt
-CREATE UNIQUE INDEX IF NOT EXISTS idx_unique_general_prompt 
-ON ai_prompts (prompt_type) 
-WHERE prompt_type = 'general';
-
--- Create a unique partial index to ensure only one system prompt
-CREATE UNIQUE INDEX IF NOT EXISTS idx_unique_system_prompt 
-ON ai_prompts (prompt_type) 
-WHERE prompt_type = 'system';
-
--- Reusable Images table for storing persistent images
-CREATE TABLE IF NOT EXISTS reusable_images (
-    id SERIAL PRIMARY KEY,
-    name TEXT NOT NULL,
-    filename TEXT NOT NULL,
-    file_path TEXT NOT NULL,
-    image_url TEXT NOT NULL,
-    is_global BOOLEAN NOT NULL DEFAULT false,
-    company TEXT,
-    mime_type TEXT,
-    file_size INTEGER,
-    created_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP WITH TIME ZONE DEFAULT CURRENT_TIMESTAMP,
-    CONSTRAINT company_required_for_non_global CHECK (
-        (is_global = true AND company IS NULL) OR
-        (is_global = false AND company IS NOT NULL)
-    )
-);
-
--- Create index on company for efficient querying
-CREATE INDEX IF NOT EXISTS idx_reusable_images_company ON reusable_images(company);
--- Create index on is_global for efficient querying
-CREATE INDEX IF NOT EXISTS idx_reusable_images_is_global ON reusable_images(is_global);
-
--- 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();
-
--- Trigger to automatically update the updated_at column for ai_prompts
-CREATE TRIGGER update_ai_prompts_updated_at
-    BEFORE UPDATE ON ai_prompts
-    FOR EACH ROW
-    EXECUTE FUNCTION update_updated_at_column();
-    
--- Trigger to automatically update the updated_at column for reusable_images
-CREATE TRIGGER update_reusable_images_updated_at
-    BEFORE UPDATE ON reusable_images
-    FOR EACH ROW
-    EXECUTE FUNCTION update_updated_at_column(); 

inventory-server/old/old_csv/update-csv.js

@@ -1,180 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-const axios = require('axios');
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate } = require('../metrics/utils/progress');
-
-// Change working directory to script directory
-process.chdir(path.dirname(__filename));
-
-require('dotenv').config({ path: path.resolve(__dirname, '..', '.env') });
-
-const FILES = [
-    {
-        name: '39f2x83-products.csv',
-        url: process.env.PRODUCTS_CSV_URL
-    },
-    {
-        name: '39f2x83-orders.csv',
-        url: process.env.ORDERS_CSV_URL
-    },
-    {
-        name: '39f2x83-purchase_orders.csv',
-        url: process.env.PURCHASE_ORDERS_CSV_URL
-    }
-];
-
-let isCancelled = false;
-
-function cancelUpdate() {
-    isCancelled = true;
-    outputProgress({
-        status: 'cancelled',
-        operation: 'CSV update cancelled',
-        current: 0,
-        total: FILES.length,
-        elapsed: null,
-        remaining: null,
-        rate: 0
-    });
-}
-
-async function downloadFile(file, index, startTime) {
-    if (isCancelled) return;
-
-    const csvDir = path.join(__dirname, '../csv');
-    if (!fs.existsSync(csvDir)) {
-        fs.mkdirSync(csvDir, { recursive: true });
-    }
-
-    const writer = fs.createWriteStream(path.join(csvDir, file.name));
-    
-    try {
-        const response = await axios({
-            url: file.url,
-            method: 'GET',
-            responseType: 'stream'
-        });
-
-        const totalLength = response.headers['content-length'];
-        let downloadedLength = 0;
-        let lastProgressUpdate = Date.now();
-        const PROGRESS_INTERVAL = 1000; // Update progress every second
-
-        response.data.on('data', (chunk) => {
-            if (isCancelled) {
-                writer.end();
-                return;
-            }
-
-            downloadedLength += chunk.length;
-            
-            // Update progress based on time interval
-            const now = Date.now();
-            if (now - lastProgressUpdate >= PROGRESS_INTERVAL) {
-                const progress = (downloadedLength / totalLength) * 100;
-                outputProgress({
-                    status: 'running',
-                    operation: `Downloading ${file.name}`,
-                    current: index + (downloadedLength / totalLength),
-                    total: FILES.length,
-                    elapsed: formatElapsedTime(startTime),
-                    remaining: estimateRemaining(startTime, index + (downloadedLength / totalLength), FILES.length),
-                    rate: calculateRate(startTime, index + (downloadedLength / totalLength)),
-                    percentage: progress.toFixed(1),
-                    file_progress: {
-                        name: file.name,
-                        downloaded: downloadedLength,
-                        total: totalLength,
-                        percentage: progress.toFixed(1)
-                    }
-                });
-                lastProgressUpdate = now;
-            }
-        });
-
-        response.data.pipe(writer);
-
-        return new Promise((resolve, reject) => {
-            writer.on('finish', resolve);
-            writer.on('error', reject);
-        });
-    } catch (error) {
-        fs.unlinkSync(path.join(csvDir, file.name));
-        throw error;
-    }
-}
-
-// Main function to update all files
-async function updateFiles() {
-    const startTime = Date.now();
-    
-    outputProgress({
-        status: 'running',
-        operation: 'Starting CSV update',
-        current: 0,
-        total: FILES.length,
-        elapsed: '0s',
-        remaining: null,
-        rate: 0,
-        percentage: '0'
-    });
-
-    try {
-        for (let i = 0; i < FILES.length; i++) {
-            if (isCancelled) {
-                return;
-            }
-
-            const file = FILES[i];
-            await downloadFile(file, i, startTime);
-
-            outputProgress({
-                status: 'running',
-                operation: 'CSV update in progress',
-                current: i + 1,
-                total: FILES.length,
-                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, i + 1, FILES.length),
-                rate: calculateRate(startTime, i + 1),
-                percentage: (((i + 1) / FILES.length) * 100).toFixed(1)
-            });
-        }
-
-        outputProgress({
-            status: 'complete',
-            operation: 'CSV update complete',
-            current: FILES.length,
-            total: FILES.length,
-            elapsed: formatElapsedTime(startTime),
-            remaining: '0s',
-            rate: calculateRate(startTime, FILES.length),
-            percentage: '100'
-        });
-    } catch (error) {
-        outputProgress({
-            status: 'error',
-            operation: 'CSV update failed',
-            error: error.message,
-            current: 0,
-            total: FILES.length,
-            elapsed: formatElapsedTime(startTime),
-            remaining: null,
-            rate: 0
-        });
-        throw error;
-    }
-}
-
-// Run the update only if this is the main module
-if (require.main === module) {
-    updateFiles().catch((error) => {
-        console.error('Error updating CSV files:', error);
-        process.exit(1);
-    });
-}
-
-// Export the functions needed by the route
-module.exports = {
-    updateFiles,
-    cancelUpdate
-}; 

inventory-server/old/scripts.js

@@ -1,180 +0,0 @@
-const readline = require('readline');
-
-const rl = readline.createInterface({
-  input: process.stdin,
-  output: process.stdout
-});
-
-const question = (query) => new Promise((resolve) => rl.question(query, resolve));
-
-async function loadScript(name) {
-  try {
-    return await require(name);
-  } catch (error) {
-    console.error(`Failed to load script ${name}:`, error);
-    return null;
-  }
-}
-
-async function runWithTimeout(fn) {
-  return new Promise((resolve, reject) => {
-    // Create a child process for the script
-    const child = require('child_process').fork(fn.toString(), [], {
-      stdio: 'inherit'
-    });
-
-    child.on('exit', (code) => {
-      if (code === 0) {
-        resolve();
-      } else {
-        reject(new Error(`Script exited with code ${code}`));
-      }
-    });
-
-    child.on('error', (err) => {
-      reject(err);
-    });
-  });
-}
-
-function clearScreen() {
-  process.stdout.write('\x1Bc');
-}
-
-const scripts = {
-  'Import Scripts': {
-    '1': { name: 'Full Import From Production', path: './import-from-prod' },
-    '2': { name: 'Individual Import Scripts ▸', submenu: {
-      '1': { name: 'Import Orders', path: './import/orders', key: 'importOrders' },
-      '2': { name: 'Import Products', path: './import/products', key: 'importProducts' },
-      '3': { name: 'Import Purchase Orders', path: './import/purchase-orders' },
-      '4': { name: 'Import Categories', path: './import/categories' },
-      'b': { name: 'Back to Main Menu' }
-    }}
-  },
-  'Metrics': {
-    '3': { name: 'Calculate All Metrics', path: './calculate-metrics' },
-    '4': { name: 'Individual Metric Scripts ▸', submenu: {
-      '1': { name: 'Brand Metrics', path: './metrics/brand-metrics' },
-      '2': { name: 'Category Metrics', path: './metrics/category-metrics' },
-      '3': { name: 'Financial Metrics', path: './metrics/financial-metrics' },
-      '4': { name: 'Product Metrics', path: './metrics/product-metrics' },
-      '5': { name: 'Sales Forecasts', path: './metrics/sales-forecasts' },
-      '6': { name: 'Time Aggregates', path: './metrics/time-aggregates' },
-      '7': { name: 'Vendor Metrics', path: './metrics/vendor-metrics' },
-      'b': { name: 'Back to Main Menu' }
-    }}
-  },
-  'Database Management': {
-    '5': { name: 'Test Production Connection', path: './test-prod-connection' }
-  },
-  'Reset Scripts': {
-    '6': { name: 'Reset Database', path: './reset-db' },
-    '7': { name: 'Reset Metrics', path: './reset-metrics' }
-  }
-};
-
-let lastRun = null;
-
-async function displayMenu(menuItems, title = 'Inventory Management Script Runner') {
-  clearScreen();
-  console.log(`\n${title}\n`);
-  
-  for (const [category, items] of Object.entries(menuItems)) {
-    console.log(`\n${category}:`);
-    Object.entries(items).forEach(([key, script]) => {
-      console.log(`${key}. ${script.name}`);
-    });
-  }
-
-  if (lastRun) {
-    console.log('\nQuick Access:');
-    console.log(`r. Repeat Last Script (${lastRun.name})`);
-  }
-  
-  console.log('\nq. Quit\n');
-}
-
-async function handleSubmenu(submenu, title) {
-  while (true) {
-    await displayMenu({"Individual Scripts": submenu}, title);
-    const choice = await question('Select an option (or b to go back): ');
-    
-    if (choice.toLowerCase() === 'b') {
-      return null;
-    }
-
-    if (submenu[choice]) {
-      return submenu[choice];
-    }
-
-    console.log('Invalid selection. Please try again.');
-    await new Promise(resolve => setTimeout(resolve, 1000));
-  }
-}
-
-async function runScript(script) {
-  console.log(`\nRunning: ${script.name}`);
-  try {
-    const scriptPath = require.resolve(script.path);
-    await runWithTimeout(scriptPath);
-    console.log('\nScript completed successfully');
-    lastRun = script;
-  } catch (error) {
-    console.error('\nError running script:', error);
-  }
-  await question('\nPress Enter to continue...');
-}
-
-async function main() {
-  while (true) {
-    await displayMenu(scripts);
-    
-    const choice = await question('Select an option: ');
-    
-    if (choice.toLowerCase() === 'q') {
-      break;
-    }
-
-    if (choice.toLowerCase() === 'r' && lastRun) {
-      await runScript(lastRun);
-      continue;
-    }
-
-    let selectedScript = null;
-    for (const category of Object.values(scripts)) {
-      if (category[choice]) {
-        selectedScript = category[choice];
-        break;
-      }
-    }
-
-    if (!selectedScript) {
-      console.log('Invalid selection. Please try again.');
-      await new Promise(resolve => setTimeout(resolve, 1000));
-      continue;
-    }
-
-    if (selectedScript.submenu) {
-      const submenuChoice = await handleSubmenu(
-        selectedScript.submenu,
-        selectedScript.name
-      );
-      if (submenuChoice && submenuChoice.path) {
-        await runScript(submenuChoice);
-      }
-    } else if (selectedScript.path) {
-      await runScript(selectedScript);
-    }
-  }
-
-  rl.close();
-  process.exit(0);
-}
-
-if (require.main === module) {
-  main().catch(error => {
-    console.error('Fatal error:', error);
-    process.exit(1);
-  });
-} 

inventory-server/old/test-connection.js

@@ -1,22 +0,0 @@
-const express = require('express');
-const router = express.Router();
-const { testConnection } = require('../../scripts/test-prod-connection');
-
-router.get('/test-prod-connection', async (req, res) => {
-  try {
-    const productCount = await testConnection();
-    res.json({ 
-      success: true, 
-      message: 'Successfully connected to production database',
-      productCount 
-    });
-  } catch (error) {
-    console.error('Production connection test failed:', error);
-    res.status(500).json({ 
-      success: false, 
-      error: error.message || 'Failed to connect to production database' 
-    });
-  }
-});
-
-module.exports = router; 

inventory-server/old/test-prod-connection.js

@@ -1,89 +0,0 @@
-const mysql = require('mysql2/promise');
-const { Client } = require('ssh2');
-const dotenv = require('dotenv');
-const path = require('path');
-
-dotenv.config({ path: path.join(__dirname, '../.env') });
-
-// SSH configuration
-const sshConfig = {
-  host: process.env.PROD_SSH_HOST,
-  port: process.env.PROD_SSH_PORT || 22,
-  username: process.env.PROD_SSH_USER,
-  privateKey: process.env.PROD_SSH_KEY_PATH ? require('fs').readFileSync(process.env.PROD_SSH_KEY_PATH) : undefined
-};
-
-// Database configuration
-const dbConfig = {
-  host: process.env.PROD_DB_HOST || 'localhost', // Usually localhost when tunneling
-  user: process.env.PROD_DB_USER,
-  password: process.env.PROD_DB_PASSWORD,
-  database: process.env.PROD_DB_NAME,
-  port: process.env.PROD_DB_PORT || 3306
-};
-
-async function testConnection() {
-  const ssh = new Client();
-
-  try {
-    // Create new Promise for SSH connection
-    await new Promise((resolve, reject) => {
-      ssh.on('ready', resolve)
-         .on('error', reject)
-         .connect(sshConfig);
-    });
-
-    console.log('SSH Connection successful!');
-
-    // Forward local port to remote MySQL port
-    const tunnel = await new Promise((resolve, reject) => {
-      ssh.forwardOut(
-        '127.0.0.1',
-        0,
-        dbConfig.host,
-        dbConfig.port,
-        (err, stream) => {
-          if (err) reject(err);
-          resolve(stream);
-        }
-      );
-    });
-
-    console.log('Port forwarding established');
-
-    // Create MySQL connection over SSH tunnel
-    const connection = await mysql.createConnection({
-      ...dbConfig,
-      stream: tunnel
-    });
-
-    console.log('MySQL Connection successful!');
-
-    // Test query
-    const [rows] = await connection.query('SELECT COUNT(*) as count FROM products');
-    console.log('Query successful! Product count:', rows[0].count);
-
-    // Clean up
-    await connection.end();
-    ssh.end();
-    console.log('Connections closed successfully');
-    return rows[0].count;
-
-  } catch (error) {
-    console.error('Error:', error);
-    if (ssh) ssh.end();
-    throw error;
-  }
-}
-
-// If running directly (not imported)
-if (require.main === module) {
-  testConnection()
-    .then(() => process.exit(0))
-    .catch(error => {
-      console.error('Test failed:', error);
-      process.exit(1);
-    });
-}
-
-module.exports = { testConnection }; 

inventory-server/package.json

@@ -1,40 +0,0 @@
-{
-  "name": "inventory-server",
-  "version": "1.0.0",
-  "description": "Backend server for inventory management system",
-  "main": "src/server.js",
-  "scripts": {
-    "start": "node src/server.js",
-    "dev": "nodemon src/server.js",
-    "prod": "pm2 start ecosystem.config.js",
-    "prod:stop": "pm2 stop inventory-server",
-    "prod:restart": "pm2 restart inventory-server",
-    "prod:logs": "pm2 logs inventory-server",
-    "prod:status": "pm2 status inventory-server",
-    "setup": "mkdir -p logs uploads",
-    "test": "echo \"Error: no test specified\" && exit 1"
-  },
-  "keywords": [],
-  "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"
-  },
-  "devDependencies": {
-    "nodemon": "^3.0.2"
-  }
-}

inventory-server/scripts/calculate-metrics.js

@@ -1,567 +0,0 @@
-const path = require('path');
-
-// Change working directory to script directory
-process.chdir(path.dirname(__filename));
-
-require('dotenv').config({ path: path.resolve(__dirname, '..', '.env') });
-
-// Configuration flags for controlling which metrics to calculate
-// Set to 1 to skip the corresponding calculation, 0 to run it
-const SKIP_PRODUCT_METRICS = 0;
-const SKIP_TIME_AGGREGATES = 0;
-const SKIP_FINANCIAL_METRICS = 0;
-const SKIP_VENDOR_METRICS = 0;
-const SKIP_CATEGORY_METRICS = 0;
-const SKIP_BRAND_METRICS = 0;
-const SKIP_SALES_FORECASTS = 0;
-
-// Add error handler for uncaught exceptions
-process.on('uncaughtException', (error) => {
-    console.error('Uncaught Exception:', error);
-    process.exit(1);
-});
-
-// Add error handler for unhandled promise rejections
-process.on('unhandledRejection', (reason, promise) => {
-    console.error('Unhandled Rejection at:', promise, 'reason:', reason);
-    process.exit(1);
-});
-
-const progress = require('./metrics/utils/progress');
-console.log('Progress module loaded:', {
-    modulePath: require.resolve('./metrics/utils/progress'),
-    exports: Object.keys(progress),
-    currentDir: process.cwd(),
-    scriptDir: __dirname
-});
-
-// Store progress functions in global scope to ensure availability
-global.formatElapsedTime = progress.formatElapsedTime;
-global.estimateRemaining = progress.estimateRemaining;
-global.calculateRate = progress.calculateRate;
-global.outputProgress = progress.outputProgress;
-global.clearProgress = progress.clearProgress;
-global.getProgress = progress.getProgress;
-global.logError = progress.logError;
-
-// List of temporary tables used in the calculation process
-const TEMP_TABLES = [
-    'temp_revenue_ranks',
-    'temp_sales_metrics',
-    'temp_purchase_metrics',
-    'temp_product_metrics',
-    'temp_vendor_metrics',
-    'temp_category_metrics',
-    'temp_brand_metrics',
-    'temp_forecast_dates',
-    'temp_daily_sales',
-    'temp_product_stats',
-    'temp_category_sales',
-    'temp_category_stats'
-];
-
-// Add cleanup function for temporary tables
-async function cleanupTemporaryTables(connection) {
-    // List of possible temporary tables that might exist
-    const tempTables = [
-        'temp_sales_metrics',
-        'temp_purchase_metrics',
-        'temp_forecast_dates',
-        'temp_daily_sales',
-        'temp_product_stats',
-        'temp_category_sales',
-        'temp_category_stats'
-    ];
-    
-    try {
-        // Drop each temporary table if it exists
-        for (const table of tempTables) {
-            await connection.query(`DROP TABLE IF EXISTS ${table}`);
-        }
-    } catch (err) {
-        console.error('Error cleaning up temporary tables:', err);
-    }
-}
-
-const { getConnection, closePool } = require('./metrics/utils/db');
-const calculateProductMetrics = require('./metrics/product-metrics');
-const calculateTimeAggregates = require('./metrics/time-aggregates');
-const calculateFinancialMetrics = require('./metrics/financial-metrics');
-const calculateVendorMetrics = require('./metrics/vendor-metrics');
-const calculateCategoryMetrics = require('./metrics/category-metrics');
-const calculateBrandMetrics = require('./metrics/brand-metrics');
-const calculateSalesForecasts = require('./metrics/sales-forecasts');
-
-// Add cancel handler
-let isCancelled = false;
-
-function cancelCalculation() {
-    isCancelled = true;
-    console.log('Calculation has been cancelled by user');
-    
-    // Force-terminate any query that's been running for more than 5 seconds
-    try {
-        const connection = getConnection();
-        connection.then(async (conn) => {
-            try {
-                // Identify and terminate long-running queries from our application
-                await conn.query(`
-                    SELECT pg_cancel_backend(pid) 
-                    FROM pg_stat_activity 
-                    WHERE query_start < now() - interval '5 seconds'
-                    AND application_name LIKE '%node%'
-                    AND query NOT LIKE '%pg_cancel_backend%'
-                `);
-                
-                // Clean up any temporary tables
-                await cleanupTemporaryTables(conn);
-                
-                // Release connection
-                conn.release();
-            } catch (err) {
-                console.error('Error during force cancellation:', err);
-                conn.release();
-            }
-        }).catch(err => {
-            console.error('Could not get connection for cancellation:', err);
-        });
-    } catch (err) {
-        console.error('Failed to terminate running queries:', err);
-    }
-    
-    return {
-        success: true,
-        message: 'Calculation has been cancelled'
-    };
-}
-
-// Handle SIGTERM signal for cancellation
-process.on('SIGTERM', cancelCalculation);
-
-// Update the main calculation function to use the new modular structure
-async function calculateMetrics() {
-    let connection;
-    const startTime = Date.now();
-    let processedProducts = 0;
-    let processedOrders = 0;
-    let processedPurchaseOrders = 0;
-    let totalProducts = 0;
-    let totalOrders = 0;
-    let totalPurchaseOrders = 0;
-    let calculateHistoryId;
-    
-    // Set a maximum execution time (30 minutes)
-    const MAX_EXECUTION_TIME = 30 * 60 * 1000;
-    const timeout = setTimeout(() => {
-        console.error(`Calculation timed out after ${MAX_EXECUTION_TIME/1000} seconds, forcing termination`);
-        // Call cancel and force exit
-        cancelCalculation();
-        process.exit(1);
-    }, MAX_EXECUTION_TIME);
-    
-    try {
-        // Clean up any previously running calculations
-        connection = await getConnection();
-        await connection.query(`
-            UPDATE calculate_history 
-            SET 
-                status = 'cancelled',
-                end_time = NOW(),
-                duration_seconds = EXTRACT(EPOCH FROM (NOW() - start_time))::INTEGER,
-                error_message = 'Previous calculation was not completed properly'
-            WHERE status = 'running'
-        `);
-
-        // Get counts from all relevant tables
-        const [productCountResult, orderCountResult, poCountResult] = await Promise.all([
-            connection.query('SELECT COUNT(*) as total FROM products'),
-            connection.query('SELECT COUNT(*) as total FROM orders'),
-            connection.query('SELECT COUNT(*) as total FROM purchase_orders')
-        ]);
-
-        totalProducts = parseInt(productCountResult.rows[0].total);
-        totalOrders = parseInt(orderCountResult.rows[0].total);
-        totalPurchaseOrders = parseInt(poCountResult.rows[0].total);
-
-        // Create history record for this calculation
-        const historyResult = await connection.query(`
-            INSERT INTO calculate_history (
-                start_time,
-                status,
-                total_products,
-                total_orders,
-                total_purchase_orders,
-                additional_info
-            ) VALUES (
-                NOW(),
-                'running',
-                $1,
-                $2,
-                $3,
-                jsonb_build_object(
-                    'skip_product_metrics', ($4::int > 0),
-                    'skip_time_aggregates', ($5::int > 0),
-                    'skip_financial_metrics', ($6::int > 0),
-                    'skip_vendor_metrics', ($7::int > 0),
-                    'skip_category_metrics', ($8::int > 0),
-                    'skip_brand_metrics', ($9::int > 0),
-                    'skip_sales_forecasts', ($10::int > 0)
-                )
-            ) RETURNING id
-        `, [
-            totalProducts,
-            totalOrders,
-            totalPurchaseOrders,
-            SKIP_PRODUCT_METRICS,
-            SKIP_TIME_AGGREGATES,
-            SKIP_FINANCIAL_METRICS, 
-            SKIP_VENDOR_METRICS,
-            SKIP_CATEGORY_METRICS,
-            SKIP_BRAND_METRICS,
-            SKIP_SALES_FORECASTS
-        ]);
-        calculateHistoryId = historyResult.rows[0].id;
-
-        // Add debug logging for the progress functions
-        console.log('Debug - Progress functions:', {
-            formatElapsedTime: typeof global.formatElapsedTime,
-            estimateRemaining: typeof global.estimateRemaining,
-            calculateRate: typeof global.calculateRate,
-            startTime: startTime
-        });
-
-        try {
-            const elapsed = global.formatElapsedTime(startTime);
-            console.log('Debug - formatElapsedTime test successful:', elapsed);
-        } catch (err) {
-            console.error('Debug - Error testing formatElapsedTime:', err);
-            throw err;
-        }
-
-        // Release the connection before getting a new one
-        connection.release();
-        isCancelled = false;
-        connection = await getConnection();
-
-        try {
-            global.outputProgress({
-                status: 'running',
-                operation: 'Starting metrics calculation',
-                current: 0,
-                total: 100,
-                elapsed: '0s',
-                remaining: 'Calculating...',
-                rate: 0,
-                percentage: '0',
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-
-            // Update progress periodically
-            const updateProgress = async (products = null, orders = null, purchaseOrders = null) => {
-                // Ensure all values are valid numbers or default to previous value
-                if (products !== null) processedProducts = Number(products) || processedProducts || 0;
-                if (orders !== null) processedOrders = Number(orders) || processedOrders || 0;
-                if (purchaseOrders !== null) processedPurchaseOrders = Number(purchaseOrders) || processedPurchaseOrders || 0;
-
-                // Ensure we never send NaN to the database
-                const safeProducts = Number(processedProducts) || 0;
-                const safeOrders = Number(processedOrders) || 0;
-                const safePurchaseOrders = Number(processedPurchaseOrders) || 0;
-
-                await connection.query(`
-                    UPDATE calculate_history 
-                    SET 
-                        processed_products = $1,
-                        processed_orders = $2,
-                        processed_purchase_orders = $3
-                    WHERE id = $4
-                `, [safeProducts, safeOrders, safePurchaseOrders, calculateHistoryId]);
-            };
-
-            // Helper function to ensure valid progress numbers
-            const ensureValidProgress = (current, total) => ({
-                current: Number(current) || 0,
-                total: Number(total) || 1,  // Default to 1 to avoid division by zero
-                percentage: (((Number(current) || 0) / (Number(total) || 1)) * 100).toFixed(1)
-            });
-
-            // Initial progress
-            const initialProgress = ensureValidProgress(0, totalProducts);
-            global.outputProgress({
-                status: 'running',
-                operation: 'Starting metrics calculation',
-                current: initialProgress.current,
-                total: initialProgress.total,
-                elapsed: '0s',
-                remaining: 'Calculating...',
-                rate: 0,
-                percentage: initialProgress.percentage,
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-
-            if (!SKIP_PRODUCT_METRICS) {
-                const result = await calculateProductMetrics(startTime, totalProducts);
-                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
-                if (!result.success) {
-                    throw new Error('Product metrics calculation failed');
-                }
-            } else {
-                console.log('Skipping product metrics calculation...');
-                processedProducts = Math.floor(totalProducts * 0.6);
-                await updateProgress(processedProducts);
-                global.outputProgress({
-                    status: 'running',
-                    operation: 'Skipping product metrics calculation',
-                    current: processedProducts,
-                    total: totalProducts,
-                    elapsed: global.formatElapsedTime(startTime),
-                    remaining: global.estimateRemaining(startTime, processedProducts, totalProducts),
-                    rate: global.calculateRate(startTime, processedProducts),
-                    percentage: '60',
-                    timing: {
-                        start_time: new Date(startTime).toISOString(),
-                        end_time: new Date().toISOString(),
-                        elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                    }
-                });
-            }
-
-            // Calculate time-based aggregates
-            if (!SKIP_TIME_AGGREGATES) {
-                const result = await calculateTimeAggregates(startTime, totalProducts, processedProducts);
-                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
-                if (!result.success) {
-                    throw new Error('Time aggregates calculation failed');
-                }
-            } else {
-                console.log('Skipping time aggregates calculation');
-            }
-
-            // Calculate financial metrics
-            if (!SKIP_FINANCIAL_METRICS) {
-                const result = await calculateFinancialMetrics(startTime, totalProducts, processedProducts);
-                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
-                if (!result.success) {
-                    throw new Error('Financial metrics calculation failed');
-                }
-            } else {
-                console.log('Skipping financial metrics calculation');
-            }
-            
-            // Calculate vendor metrics
-            if (!SKIP_VENDOR_METRICS) {
-                const result = await calculateVendorMetrics(startTime, totalProducts, processedProducts);
-                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
-                if (!result.success) {
-                    throw new Error('Vendor metrics calculation failed');
-                }
-            } else {
-                console.log('Skipping vendor metrics calculation');
-            }
-
-            // Calculate category metrics
-            if (!SKIP_CATEGORY_METRICS) {
-                const result = await calculateCategoryMetrics(startTime, totalProducts, processedProducts);
-                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
-                if (!result.success) {
-                    throw new Error('Category metrics calculation failed');
-                }
-            } else {
-                console.log('Skipping category metrics calculation');
-            }
-
-            // Calculate brand metrics
-            if (!SKIP_BRAND_METRICS) {
-                const result = await calculateBrandMetrics(startTime, totalProducts, processedProducts);
-                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
-                if (!result.success) {
-                    throw new Error('Brand metrics calculation failed');
-                }
-            } else {
-                console.log('Skipping brand metrics calculation');
-            }
-
-            // Calculate sales forecasts
-            if (!SKIP_SALES_FORECASTS) {
-                const result = await calculateSalesForecasts(startTime, totalProducts, processedProducts);
-                await updateProgress(result.processedProducts, result.processedOrders, result.processedPurchaseOrders);
-                if (!result.success) {
-                    throw new Error('Sales forecasts calculation failed');
-                }
-            } else {
-                console.log('Skipping sales forecasts calculation');
-            }
-
-            // Final progress update with guaranteed valid numbers
-            const finalProgress = ensureValidProgress(totalProducts, totalProducts);
-            
-            // Final success message
-            outputProgress({
-                status: 'complete',
-                operation: 'Metrics calculation complete',
-                current: finalProgress.current,
-                total: finalProgress.total,
-                elapsed: global.formatElapsedTime(startTime),
-                remaining: '0s',
-                rate: global.calculateRate(startTime, finalProgress.current),
-                percentage: '100',
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-
-            // Ensure all values are valid numbers before final update
-            const finalStats = {
-                processedProducts: Number(processedProducts) || 0,
-                processedOrders: Number(processedOrders) || 0,
-                processedPurchaseOrders: Number(processedPurchaseOrders) || 0
-            };
-
-            // Update history with completion
-            await connection.query(`
-                UPDATE calculate_history 
-                SET 
-                    end_time = NOW(),
-                    duration_seconds = $1,
-                    processed_products = $2,
-                    processed_orders = $3,
-                    processed_purchase_orders = $4,
-                    status = 'completed'
-                WHERE id = $5
-            `, [Math.round((Date.now() - startTime) / 1000), 
-                finalStats.processedProducts,
-                finalStats.processedOrders, 
-                finalStats.processedPurchaseOrders,
-                calculateHistoryId]);
-
-            // Clear progress file on successful completion
-            global.clearProgress();
-
-            return {
-                success: true,
-                message: 'Calculation completed successfully',
-                duration: Math.round((Date.now() - startTime) / 1000)
-            };
-        } catch (error) {
-            const endTime = Date.now();
-            const totalElapsedSeconds = Math.round((endTime - startTime) / 1000);
-
-            // Update history with error
-            await connection.query(`
-                UPDATE calculate_history 
-                SET 
-                    end_time = NOW(),
-                    duration_seconds = $1,
-                    processed_products = $2,
-                    processed_orders = $3,
-                    processed_purchase_orders = $4,
-                    status = $5,
-                    error_message = $6
-                WHERE id = $7
-            `, [
-                totalElapsedSeconds,
-                processedProducts || 0,  // Ensure we have a valid number
-                processedOrders || 0,    // Ensure we have a valid number
-                processedPurchaseOrders || 0,  // Ensure we have a valid number
-                isCancelled ? 'cancelled' : 'failed',
-                error.message,
-                calculateHistoryId
-            ]);
-
-            if (isCancelled) {
-                global.outputProgress({
-                    status: 'cancelled',
-                    operation: 'Calculation cancelled',
-                    current: processedProducts,
-                    total: totalProducts || 0,
-                    elapsed: global.formatElapsedTime(startTime),
-                    remaining: null,
-                    rate: global.calculateRate(startTime, processedProducts),
-                    percentage: ((processedProducts / (totalProducts || 1)) * 100).toFixed(1),
-                    timing: {
-                        start_time: new Date(startTime).toISOString(),
-                        end_time: new Date().toISOString(),
-                        elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                    }
-                });
-            } else {
-                global.outputProgress({
-                    status: 'error',
-                    operation: 'Error: ' + error.message,
-                    current: processedProducts,
-                    total: totalProducts || 0,
-                    elapsed: global.formatElapsedTime(startTime),
-                    remaining: null,
-                    rate: global.calculateRate(startTime, processedProducts),
-                    percentage: ((processedProducts / (totalProducts || 1)) * 100).toFixed(1),
-                    timing: {
-                        start_time: new Date(startTime).toISOString(),
-                        end_time: new Date().toISOString(),
-                        elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                    }
-                });
-            }
-            throw error;
-        } finally {
-            // Clear the timeout to prevent forced termination
-            clearTimeout(timeout);
-            
-            // Always clean up and release connection
-            if (connection) {
-                try {
-                    await cleanupTemporaryTables(connection);
-                    connection.release();
-                } catch (err) {
-                    console.error('Error in final cleanup:', err);
-                }
-            }
-        }
-    } catch (error) {
-        console.error('Error in metrics calculation', error);
-        
-        try {
-            if (connection) {
-                await connection.query(`
-                    UPDATE calculate_history 
-                    SET 
-                        status = 'error',
-                        end_time = NOW(),
-                        duration_seconds = EXTRACT(EPOCH FROM (NOW() - start_time))::INTEGER,
-                        error_message = $1
-                    WHERE id = $2
-                `, [error.message.substring(0, 500), calculateHistoryId]);
-            }
-        } catch (updateError) {
-            console.error('Error updating calculation history:', updateError);
-        }
-        
-        throw error;
-    }
-}
-
-// Export as a module with all necessary functions
-module.exports = {
-    calculateMetrics,
-    cancelCalculation,
-    getProgress: global.getProgress
-};
-
-// Run directly if called from command line
-if (require.main === module) {
-    calculateMetrics().catch(error => {
-        if (!error.message.includes('Operation cancelled')) {
-            console.error('Error:', error);
-        }
-        process.exit(1);
-    });
-} 

inventory-server/scripts/full-reset.js

@@ -1,115 +0,0 @@
-const path = require('path');
-const { spawn } = require('child_process');
-
-function outputProgress(data) {
-    if (!data.status) {
-        data = {
-            status: 'running',
-            ...data
-        };
-    }
-    console.log(JSON.stringify(data));
-}
-
-function runScript(scriptPath) {
-    return new Promise((resolve, reject) => {
-        const child = spawn('node', [scriptPath], {
-            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 = '';
-
-        child.stdout.on('data', (data) => {
-            const lines = data.toString().split('\n');
-            lines.filter(line => line.trim()).forEach(line => {
-                try {
-                    console.log(line); // Pass through the JSON output
-                    output += line + '\n';
-                } catch (e) {
-                    console.log(line); // If not JSON, just log it directly
-                }
-            });
-        });
-
-        child.stderr.on('data', (data) => {
-            console.error(data.toString());
-        });
-
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Script ${scriptPath} exited with code ${code}`));
-            } else {
-                resolve(output);
-            }
-        });
-
-        child.on('error', (err) => {
-            reject(err);
-        });
-    });
-}
-
-async function fullReset() {
-    try {
-        // Step 1: Reset Database
-        outputProgress({
-            operation: 'Starting full reset',
-            message: 'Step 1/3: Resetting database...'
-        });
-        await runScript(path.join(__dirname, 'reset-db.js'));
-        outputProgress({
-            status: 'complete',
-            operation: 'Database reset step complete',
-            message: 'Database reset finished, moving to import...'
-        });
-
-        // Step 2: Import from Production
-        outputProgress({
-            operation: 'Starting import',
-            message: 'Step 2/3: Importing from production...'
-        });
-        await runScript(path.join(__dirname, 'import-from-prod.js'));
-        outputProgress({
-            status: 'complete',
-            operation: 'Import step complete',
-            message: 'Import finished, moving to metrics calculation...'
-        });
-
-        // Step 3: Calculate Metrics
-        outputProgress({
-            operation: 'Starting metrics calculation',
-            message: 'Step 3/3: Calculating metrics...'
-        });
-        await runScript(path.join(__dirname, 'calculate-metrics.js'));
-        
-        // Final completion message
-        outputProgress({
-            status: 'complete',
-            operation: 'Full reset complete',
-            message: 'Successfully completed all steps: database reset, import, and metrics calculation'
-        });
-    } catch (error) {
-        outputProgress({
-            status: 'error',
-            operation: 'Full reset failed',
-            error: error.message,
-            stack: error.stack
-        });
-        process.exit(1);
-    }
-}
-
-// Run if called directly
-if (require.main === module) {
-    fullReset();
-}
-
-module.exports = fullReset; 

inventory-server/scripts/full-update.js

@@ -1,100 +0,0 @@
-const path = require('path');
-const { spawn } = require('child_process');
-
-function outputProgress(data) {
-    if (!data.status) {
-        data = {
-            status: 'running',
-            ...data
-        };
-    }
-    console.log(JSON.stringify(data));
-}
-
-function runScript(scriptPath) {
-    return new Promise((resolve, reject) => {
-        const child = spawn('node', [scriptPath], {
-            stdio: ['inherit', 'pipe', 'pipe']
-        });
-
-        let output = '';
-
-        child.stdout.on('data', (data) => {
-            const lines = data.toString().split('\n');
-            lines.filter(line => line.trim()).forEach(line => {
-                try {
-                    console.log(line); // Pass through the JSON output
-                    output += line + '\n';
-                } catch (e) {
-                    console.log(line); // If not JSON, just log it directly
-                }
-            });
-        });
-
-        child.stderr.on('data', (data) => {
-            console.error(data.toString());
-        });
-
-        child.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Script ${scriptPath} exited with code ${code}`));
-            } else {
-                resolve(output);
-            }
-        });
-
-        child.on('error', (err) => {
-            reject(err);
-        });
-    });
-}
-
-async function fullUpdate() {
-    try {
-        // Step 1: Import from Production
-        outputProgress({
-            operation: 'Starting full update',
-            message: 'Step 1/2: Importing from production...'
-        });
-        await runScript(path.join(__dirname, 'import-from-prod.js'));
-        outputProgress({
-            status: 'complete',
-            operation: 'Import step complete',
-            message: 'Import finished, moving to metrics calculation...'
-        });
-
-        // Step 2: Calculate Metrics
-        outputProgress({
-            operation: 'Starting metrics calculation',
-            message: 'Step 2/2: Calculating metrics...'
-        });
-        await runScript(path.join(__dirname, 'calculate-metrics.js'));
-        outputProgress({
-            status: 'complete',
-            operation: 'Metrics step complete',
-            message: 'Metrics calculation finished'
-        });
-
-        // Final completion message
-        outputProgress({
-            status: 'complete',
-            operation: 'Full update complete',
-            message: 'Successfully completed all steps: import and metrics calculation'
-        });
-    } catch (error) {
-        outputProgress({
-            status: 'error',
-            operation: 'Full update failed',
-            error: error.message,
-            stack: error.stack
-        });
-        process.exit(1);
-    }
-}
-
-// Run if called directly
-if (require.main === module) {
-    fullUpdate();
-}
-
-module.exports = fullUpdate; 

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

@@ -1,339 +0,0 @@
-const dotenv = require("dotenv");
-const path = require("path");
-const { outputProgress, formatElapsedTime } = require('./metrics/utils/progress');
-const { setupConnections, closeConnections } = require('./import/utils');
-const importCategories = require('./import/categories');
-const { importProducts } = require('./import/products');
-const importOrders = require('./import/orders');
-const importPurchaseOrders = require('./import/purchase-orders');
-
-dotenv.config({ path: path.join(__dirname, "../.env") });
-
-// Constants to control which imports run
-const IMPORT_CATEGORIES = false;
-const IMPORT_PRODUCTS = false;
-const IMPORT_ORDERS = false;
-const IMPORT_PURCHASE_ORDERS = true;
-
-// Add flag for incremental updates
-const INCREMENTAL_UPDATE = process.env.INCREMENTAL_UPDATE !== 'false';  // Default to true unless explicitly set to false
-
-// SSH configuration
-const sshConfig = {
-  ssh: {
-    host: process.env.PROD_SSH_HOST,
-    port: process.env.PROD_SSH_PORT || 22,
-    username: process.env.PROD_SSH_USER,
-    privateKey: process.env.PROD_SSH_KEY_PATH
-      ? require("fs").readFileSync(process.env.PROD_SSH_KEY_PATH)
-      : undefined,
-    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,
-    database: process.env.PROD_DB_NAME,
-    port: process.env.PROD_DB_PORT || 3306,
-    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,
-    port: process.env.DB_PORT || 5432,
-    ssl: process.env.DB_SSL === 'true',
-    connectionTimeoutMillis: 60000,
-    idleTimeoutMillis: 30000,
-    max: 10 // connection pool max size
-  }
-};
-
-let isImportCancelled = false;
-
-// Add cancel function
-function cancelImport() {
-    isImportCancelled = true;
-    outputProgress({
-        status: 'cancelled',
-        operation: 'Import process',
-        message: 'Import cancelled by user',
-        current: 0,
-        total: 0,
-        elapsed: null,
-        remaining: null,
-        rate: 0
-    });
-}
-
-async function main() {
-  const startTime = Date.now();
-  let connections;
-  let completedSteps = 0;
-  let importHistoryId;
-  const totalSteps = [
-    IMPORT_CATEGORIES,
-    IMPORT_PRODUCTS,
-    IMPORT_ORDERS,
-    IMPORT_PURCHASE_ORDERS
-  ].filter(Boolean).length;
-
-  try {
-    // Initial progress update
-    outputProgress({
-      status: "running",
-      operation: "Import process",
-      message: `Initializing SSH tunnel for ${INCREMENTAL_UPDATE ? 'incremental' : 'full'} import...`,
-      current: completedSteps,
-      total: totalSteps,
-      elapsed: formatElapsedTime(startTime)
-    });
-
-    connections = await setupConnections(sshConfig);
-    const { prodConnection, localConnection } = connections;
-
-    if (isImportCancelled) throw new Error("Import cancelled");
-
-    // Clean up any previously running imports that weren't completed
-    await localConnection.query(`
-      UPDATE import_history 
-      SET 
-        status = 'cancelled',
-        end_time = NOW(),
-        duration_seconds = EXTRACT(EPOCH FROM (NOW() - start_time))::INTEGER,
-        error_message = 'Previous import was not completed properly'
-      WHERE status = 'running'
-    `);
-
-    // Initialize sync_status table if it doesn't exist
-    await localConnection.query(`
-      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
-      );
-
-      CREATE INDEX IF NOT EXISTS idx_last_sync ON sync_status (last_sync_timestamp);
-    `);
-
-    // Create import history record for the overall session
-    try {
-      const [historyResult] = await localConnection.query(`
-        INSERT INTO import_history (
-          table_name, 
-          start_time, 
-          is_incremental,
-          status,
-          additional_info
-        ) VALUES (
-          'all_tables',
-          NOW(),
-          $1::boolean,
-          'running',
-          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.rows[0].id;
-    } catch (error) {
-      console.error("Error creating import history record:", error);
-      outputProgress({
-        status: "error",
-        operation: "Import process",
-        message: "Failed to create import history record",
-        error: error.message
-      });
-      throw error;
-    }
-
-    const results = {
-      categories: null,
-      products: null,
-      orders: null,
-      purchaseOrders: null
-    };
-
-    let totalRecordsAdded = 0;
-    let totalRecordsUpdated = 0;
-
-    // Run each import based on constants
-    if (IMPORT_CATEGORIES) {
-      results.categories = await importCategories(prodConnection, localConnection);
-      if (isImportCancelled) throw new Error("Import cancelled");
-      completedSteps++;
-      console.log('Categories import result:', results.categories);
-      totalRecordsAdded += parseInt(results.categories?.recordsAdded || 0) || 0;
-      totalRecordsUpdated += parseInt(results.categories?.recordsUpdated || 0) || 0;
-    }
-
-    if (IMPORT_PRODUCTS) {
-      results.products = await importProducts(prodConnection, localConnection, INCREMENTAL_UPDATE);
-      if (isImportCancelled) throw new Error("Import cancelled");
-      completedSteps++;
-      console.log('Products import result:', results.products);
-      totalRecordsAdded += parseInt(results.products?.recordsAdded || 0) || 0;
-      totalRecordsUpdated += parseInt(results.products?.recordsUpdated || 0) || 0;
-    }
-
-    if (IMPORT_ORDERS) {
-      results.orders = await importOrders(prodConnection, localConnection, INCREMENTAL_UPDATE);
-      if (isImportCancelled) throw new Error("Import cancelled");
-      completedSteps++;
-      console.log('Orders import result:', results.orders);
-      totalRecordsAdded += parseInt(results.orders?.recordsAdded || 0) || 0;
-      totalRecordsUpdated += parseInt(results.orders?.recordsUpdated || 0) || 0;
-    }
-
-    if (IMPORT_PURCHASE_ORDERS) {
-      try {
-        results.purchaseOrders = await importPurchaseOrders(prodConnection, localConnection, INCREMENTAL_UPDATE);
-        if (isImportCancelled) throw new Error("Import cancelled");
-        completedSteps++;
-        console.log('Purchase orders import result:', results.purchaseOrders);
-        
-        // Handle potential error status
-        if (results.purchaseOrders?.status === 'error') {
-          console.error('Purchase orders import had an error:', results.purchaseOrders.error);
-        } else {
-          totalRecordsAdded += parseInt(results.purchaseOrders?.recordsAdded || 0) || 0;
-          totalRecordsUpdated += parseInt(results.purchaseOrders?.recordsUpdated || 0) || 0;
-        }
-      } catch (error) {
-        console.error('Error during purchase orders import:', error);
-        // Continue with other imports, don't fail the whole process
-        results.purchaseOrders = {
-          status: 'error',
-          error: error.message,
-          recordsAdded: 0,
-          recordsUpdated: 0
-        };
-      }
-    }
-
-    const endTime = Date.now();
-    const totalElapsedSeconds = Math.round((endTime - startTime) / 1000);
-
-    // Update import history with final stats
-    await localConnection.query(`
-      UPDATE import_history 
-      SET 
-        end_time = NOW(),
-        duration_seconds = $1,
-        records_added = $2,
-        records_updated = $3,
-        status = 'completed',
-        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 = $12
-    `, [
-      totalElapsedSeconds,
-      parseInt(totalRecordsAdded) || 0,
-      parseInt(totalRecordsUpdated) || 0,
-      IMPORT_CATEGORIES,
-      IMPORT_PRODUCTS,
-      IMPORT_ORDERS,
-      IMPORT_PURCHASE_ORDERS,
-      JSON.stringify(results.categories),
-      JSON.stringify(results.products),
-      JSON.stringify(results.orders),
-      JSON.stringify(results.purchaseOrders),
-      importHistoryId
-    ]);
-
-    outputProgress({
-      status: "complete",
-      operation: "Import process",
-      message: `${INCREMENTAL_UPDATE ? 'Incremental' : 'Full'} import completed successfully in ${formatElapsedTime(totalElapsedSeconds)}`,
-      current: completedSteps,
-      total: totalSteps,
-      elapsed: formatElapsedTime(startTime),
-      timing: {
-        start_time: new Date(startTime).toISOString(),
-        end_time: new Date(endTime).toISOString(),
-        elapsed_time: formatElapsedTime(startTime),
-        elapsed_seconds: totalElapsedSeconds,
-        total_duration: formatElapsedTime(totalElapsedSeconds)
-      },
-      results
-    });
-
-    return results;
-  } catch (error) {
-    const endTime = Date.now();
-    const totalElapsedSeconds = Math.round((endTime - startTime) / 1000);
-
-    // Update import history with error
-    if (importHistoryId && connections?.localConnection) {
-      await connections.localConnection.query(`
-        UPDATE import_history 
-        SET 
-          end_time = NOW(),
-          duration_seconds = $1,
-          status = $2,
-          error_message = $3
-        WHERE id = $4
-      `, [totalElapsedSeconds, error.message === "Import cancelled" ? 'cancelled' : 'failed', error.message, importHistoryId]);
-    }
-
-    console.error("Error during import process:", error);
-    outputProgress({
-      status: error.message === "Import cancelled" ? "cancelled" : "error",
-      operation: "Import process",
-      message: error.message === "Import cancelled" 
-        ? `${INCREMENTAL_UPDATE ? 'Incremental' : 'Full'} import cancelled by user after ${formatElapsedTime(totalElapsedSeconds)}`
-        : `${INCREMENTAL_UPDATE ? 'Incremental' : 'Full'} import failed after ${formatElapsedTime(totalElapsedSeconds)}`,
-      error: error.message,
-      current: completedSteps,
-      total: totalSteps,
-      elapsed: formatElapsedTime(startTime),
-      timing: {
-        start_time: new Date(startTime).toISOString(),
-        end_time: new Date(endTime).toISOString(),
-        elapsed_time: formatElapsedTime(startTime),
-        elapsed_seconds: totalElapsedSeconds,
-        total_duration: formatElapsedTime(totalElapsedSeconds)
-      }
-    });
-    throw error;
-  } finally {
-    if (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().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);
-    // Force exit with error code after a small delay
-    setTimeout(() => process.exit(1), 500);
-  });
-}
-
-// Export the functions needed by the route
-module.exports = {
-  main,
-  cancelImport,
-};

inventory-server/scripts/import/categories.js

@@ -1,195 +0,0 @@
-const { outputProgress, formatElapsedTime } = require('../metrics/utils/progress');
-
-async function importCategories(prodConnection, localConnection) {
-  outputProgress({
-    operation: "Starting categories import",
-    status: "running",
-  });
-
-  const startTime = Date.now();
-  const typeOrder = [10, 20, 11, 21, 12, 13];
-  let totalInserted = 0;
-  let totalUpdated = 0;
-  let skippedCategories = [];
-
-  try {
-    // 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) {
-      try {
-        // Create a savepoint for this type
-        await localConnection.query(`SAVEPOINT category_type_${type}`);
-
-        // 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 (categories.length === 0) {
-          await localConnection.query(`RELEASE SAVEPOINT category_type_${type}`);
-          continue;
-        }
-
-        console.log(`Processing ${categories.length} type ${type} categories`);
-
-        // For types that can have parents (11, 21, 12, 13), we'll proceed directly
-        // No need to check for parent existence since we process in hierarchical order
-        let categoriesToInsert = categories;
-
-        if (categoriesToInsert.length === 0) {
-          console.log(`No valid categories of type ${type} to insert`);
-          await localConnection.query(`RELEASE SAVEPOINT category_type_${type}`);
-          continue;
-        }
-
-        // 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()
-        ]);
-
-        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(',');
-
-        // 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`;
-        
-        const result = await localConnection.query(query, values);
-
-        // 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');
-          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;
-      }
-    }
-
-    // Commit the entire transaction - we'll do this even if we have skipped categories
-    await localConnection.query('COMMIT');
-
-    // Update sync status
-    await localConnection.query(`
-      INSERT INTO sync_status (table_name, last_sync_timestamp)
-      VALUES ('categories', NOW())
-      ON CONFLICT (table_name) DO UPDATE SET
-        last_sync_timestamp = NOW()
-    `);
-
-    outputProgress({
-      status: "complete",
-      operation: "Categories import completed",
-      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",
-      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);
-    
-    // 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
-    });
-
-    throw error;
-  }
-}
-
-module.exports = importCategories; 

inventory-server/scripts/import/orders.js

@@ -1,619 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate } = require('../metrics/utils/progress');
-const { importMissingProducts, setupTemporaryTables, cleanupTemporaryTables, materializeCalculations } = require('./products');
-
-/**
- * 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.
- *
- * @param {object} prodConnection - A MySQL connection to production DB (MySQL 5.7).
- * @param {object} localConnection - A MySQL connection to local DB (MySQL 8.0).
- * @param {boolean} incrementalUpdate - Set to false for a full sync; true for incremental.
- *
- * @returns {object} Information about the sync operation.
- */
-async function importOrders(prodConnection, localConnection, incrementalUpdate = true) {
-  const startTime = Date.now();
-  const skippedOrders = new Set();
-  const missingProducts = new Set();
-  let recordsAdded = 0;
-  let recordsUpdated = 0;
-  let processedCount = 0;
-  let importedCount = 0;
-  let totalOrderItems = 0;
-  let totalUniqueOrders = 0;
-  let cumulativeProcessedOrders = 0;
-
-  try {
-    // Begin transaction
-    await localConnection.beginTransaction();
-    
-    // Get last sync info
-    const [syncInfo] = await localConnection.query(
-      "SELECT last_sync_timestamp FROM sync_status WHERE table_name = 'orders'"
-    );
-    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 - Keep MySQL compatible for production
-    const [[{ total }]] = await prodConnection.query(`
-      SELECT COUNT(*) as total
-      FROM order_items oi
-      JOIN _order o ON oi.order_id = o.order_id
-      WHERE o.order_status >= 15
-        AND o.date_placed_onlydate >= DATE_SUB(CURRENT_DATE, INTERVAL ${incrementalUpdate ? '1' : '5'} YEAR)
-        AND o.date_placed_onlydate IS NOT NULL
-        ${incrementalUpdate ? `
-          AND (
-            o.stamp > ? 
-            OR oi.stamp > ?
-            OR EXISTS (
-              SELECT 1 FROM order_discount_items odi 
-              WHERE odi.order_id = o.order_id 
-              AND odi.pid = oi.prod_pid
-            )
-            OR EXISTS (
-              SELECT 1 FROM order_tax_info oti 
-              JOIN order_tax_info_products otip ON oti.taxinfo_id = otip.taxinfo_id
-              WHERE oti.order_id = o.order_id 
-              AND otip.pid = oi.prod_pid
-              AND oti.stamp > ?
-            )
-          )
-        ` : ''}
-    `, incrementalUpdate ? [lastSyncTime, lastSyncTime, lastSyncTime] : []);
-
-    totalOrderItems = total;
-    console.log('Orders: Found changes:', totalOrderItems);
-
-    // 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,
-        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,
-        oi.stamp as last_modified
-      FROM order_items oi
-      JOIN _order o ON oi.order_id = o.order_id
-      WHERE o.order_status >= 15
-        AND o.date_placed_onlydate >= DATE_SUB(CURRENT_DATE, INTERVAL ${incrementalUpdate ? '1' : '5'} YEAR)
-        AND o.date_placed_onlydate IS NOT NULL
-        ${incrementalUpdate ? `
-          AND (
-            o.stamp > ? 
-            OR oi.stamp > ?
-            OR EXISTS (
-              SELECT 1 FROM order_discount_items odi 
-              WHERE odi.order_id = o.order_id 
-              AND odi.pid = oi.prod_pid
-            )
-            OR EXISTS (
-              SELECT 1 FROM order_tax_info oti 
-              JOIN order_tax_info_products otip ON oti.taxinfo_id = otip.taxinfo_id
-              WHERE oti.order_id = o.order_id 
-              AND otip.pid = oi.prod_pid
-              AND oti.stamp > ?
-            )
-          )
-        ` : ''}
-    `, incrementalUpdate ? [lastSyncTime, lastSyncTime, lastSyncTime] : []);
-
-    console.log('Orders: Found', orderItems.length, 'order items to process');
-
-    // Create tables in PostgreSQL for data processing
-    await localConnection.query(`
-      DROP TABLE IF EXISTS temp_order_items;
-      DROP TABLE IF EXISTS temp_order_meta;
-      DROP TABLE IF EXISTS temp_order_discounts;
-      DROP TABLE IF EXISTS temp_order_taxes;
-      DROP TABLE IF EXISTS temp_order_costs;
-
-      CREATE TEMP TABLE temp_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 TEMP TABLE temp_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 TEMP TABLE temp_order_discounts (
-        order_id INTEGER NOT NULL,
-        pid INTEGER NOT NULL,
-        discount DECIMAL(10,2) NOT NULL,
-        PRIMARY KEY (order_id, pid)
-      );
-
-      CREATE TEMP TABLE temp_order_taxes (
-        order_id INTEGER NOT NULL,
-        pid INTEGER NOT NULL,
-        tax DECIMAL(10,2) NOT NULL,
-        PRIMARY KEY (order_id, pid)
-      );
-
-      CREATE TEMP TABLE temp_order_costs (
-        order_id INTEGER NOT NULL,
-        pid INTEGER NOT NULL,
-        costeach DECIMAL(10,3) DEFAULT 0.000,
-        PRIMARY KEY (order_id, pid)
-      );
-
-      CREATE INDEX idx_temp_order_items_pid ON temp_order_items(pid);
-      CREATE INDEX idx_temp_order_meta_order_id ON temp_order_meta(order_id);
-    `);
-
-    // 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((_, 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.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)
-        VALUES ${placeholders}
-        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;
-      outputProgress({
-        status: "running",
-        operation: "Orders import",
-        message: `Loading order items: ${processedCount} of ${totalOrderItems}`,
-        current: processedCount,
-        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('Orders: Processing', totalUniqueOrders, 'unique orders');
-
-    // Reset processed count for order processing phase
-    processedCount = 0;
-
-    // Process metadata, discounts, taxes, and costs in parallel
-    const METADATA_BATCH_SIZE = 2000;
-    const PG_BATCH_SIZE = 200;
-    
-    // Add a helper function for title case conversion
-    function toTitleCase(str) {
-      if (!str) return '';
-      return str.toLowerCase().split(' ').map(word => {
-        return word.charAt(0).toUpperCase() + word.slice(1);
-      }).join(' ');
-    }
-
-    const processMetadataBatch = async (batchIds) => {
-      const [orders] = await prodConnection.query(`
-        SELECT 
-          o.order_id,
-          o.date_placed_onlydate as date,
-          o.order_cid as customer,
-          CONCAT(COALESCE(u.firstname, ''), ' ', COALESCE(u.lastname, '')) as customer_name,
-          o.order_status as status,
-          CASE WHEN o.date_cancelled != '0000-00-00 00:00:00' THEN 1 ELSE 0 END as canceled,
-          o.summary_discount,
-          o.summary_subtotal
-        FROM _order o
-        LEFT JOIN users u ON o.order_cid = u.cid
-        WHERE o.order_id IN (?)
-      `, [batchIds]);
-
-      // 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,
-          toTitleCase(order.customer_name) || '',
-          order.status,
-          order.canceled,
-          order.summary_discount || 0,
-          order.summary_subtotal || 0
-        ]);
-
-        await localConnection.query(`
-          INSERT INTO temp_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 processDiscountsBatch = async (batchIds) => {
-      const [discounts] = await prodConnection.query(`
-        SELECT order_id, pid, SUM(amount) as discount
-        FROM order_discount_items
-        WHERE order_id IN (?)
-        GROUP BY order_id, pid
-      `, [batchIds]);
-
-      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 (order_id, pid, discount)
-          VALUES ${placeholders}
-          ON CONFLICT (order_id, pid) DO UPDATE SET
-            discount = EXCLUDED.discount
-        `, values);
-      }
-    };
-
-    const processTaxesBatch = async (batchIds) => {
-      // Optimized tax query to avoid subquery
-      const [taxes] = await prodConnection.query(`
-        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_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) return;
-
-      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;
-
-        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
-        ]);
-
-        await localConnection.query(`
-          INSERT INTO temp_order_taxes (order_id, pid, tax)
-          VALUES ${placeholders}
-          ON CONFLICT (order_id, pid) DO UPDATE SET
-            tax = EXCLUDED.tax
-        `, values);
-      }
-    };
-
-    const processCostsBatch = async (batchIds) => {
-      // Modified query to ensure one row per order_id/pid by using a subquery
-      const [costs] = await prodConnection.query(`
-        SELECT 
-          oc.orderid as order_id,
-          oc.pid,
-          oc.costeach
-        FROM order_costs oc
-        INNER JOIN (
-          SELECT 
-            orderid,
-            pid, 
-            MAX(id) as max_id
-          FROM order_costs
-          WHERE orderid IN (?) 
-            AND pending = 0
-          GROUP BY orderid, pid
-        ) latest ON oc.orderid = latest.orderid AND oc.pid = latest.pid AND oc.id = latest.max_id
-      `, [batchIds]);
-
-      if (costs.length === 0) return;
-
-      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 values = subBatch.flatMap(c => [
-          c.order_id,
-          c.pid,
-          c.costeach || 0
-        ]);
-
-        await localConnection.query(`
-          INSERT INTO temp_order_costs (order_id, pid, costeach)
-          VALUES ${placeholders}
-          ON CONFLICT (order_id, pid) DO UPDATE SET
-            costeach = EXCLUDED.costeach
-        `, values);
-      }
-    };
-
-    // 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: `Loading order data: ${processedCount} of ${totalUniqueOrders}`,
-        current: processedCount,
-        total: totalUniqueOrders,
-        elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
-        remaining: estimateRemaining(startTime, processedCount, totalUniqueOrders),
-        rate: calculateRate(startTime, processedCount)
-      });
-    }
-
-    // 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 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(oc.costeach, oi.price * 0.5) as costeach
-            FROM temp_order_items oi
-            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 oc ON oi.order_id = oc.order_id AND oi.pid = oc.pid
-            GROUP BY oi.order_id, oi.pid, ot.tax, oc.costeach
-          )
-          SELECT 
-            oi.order_id as order_number,
-            oi.pid::bigint as pid,
-            oi.SKU as sku,
-            om.date,
-            oi.price,
-            oi.quantity,
-            (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)::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(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 temp_order_items
-            WHERE order_id = ANY($1)
-            ORDER BY order_id, pid
-          ) oi
-          JOIN temp_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]);
-
-        // 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);
-        }
-
-        // 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 * 15;  // 15 columns including costeach
-            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}, $${base + 15})`;
-          }).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,
-            o.costeach
-          ]);
-
-          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, costeach
-              )
-              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,
-                costeach = EXCLUDED.costeach
-              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 += parseInt(inserted) || 0;
-          recordsUpdated += parseInt(updated) || 0;
-          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)
-        });
-      }
-    }
-
-    // Update sync status
-    await localConnection.query(`
-      INSERT INTO sync_status (table_name, last_sync_timestamp)
-      VALUES ('orders', NOW())
-      ON CONFLICT (table_name) DO UPDATE SET
-        last_sync_timestamp = NOW()
-    `);
-    
-    // Cleanup temporary tables
-    await localConnection.query(`
-      DROP TABLE IF EXISTS temp_order_items;
-      DROP TABLE IF EXISTS temp_order_meta;
-      DROP TABLE IF EXISTS temp_order_discounts;
-      DROP TABLE IF EXISTS temp_order_taxes;
-      DROP TABLE IF EXISTS temp_order_costs;
-    `);
-    
-    // Commit transaction
-    await localConnection.commit();
-
-    return {
-      status: "complete",
-      totalImported: Math.floor(importedCount) || 0,
-      recordsAdded: parseInt(recordsAdded) || 0,
-      recordsUpdated: parseInt(recordsUpdated) || 0,
-      totalSkipped: skippedOrders.size || 0,
-      missingProducts: missingProducts.size || 0,
-      incrementalUpdate,
-      lastSyncTime
-    };
-  } catch (error) {
-    console.error("Error during orders import:", error);
-    
-    // Rollback transaction
-    try {
-      await localConnection.rollback();
-    } catch (rollbackError) {
-      console.error("Error during rollback:", rollbackError);
-    }
-    
-    throw error;
-  }
-}
-
-module.exports = importOrders;

inventory-server/scripts/import/products.js

@@ -1,879 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate } = require('../metrics/utils/progress');
-const BATCH_SIZE = 1000; // Smaller batch size for better progress tracking
-const MAX_RETRIES = 3;
-const RETRY_DELAY = 5000; // 5 seconds
-const dotenv = require("dotenv");
-const path = require("path");
-dotenv.config({ path: path.join(__dirname, "../../.env") });
-
-// Utility functions
-const imageUrlBase = process.env.PRODUCT_IMAGE_URL_BASE || 'https://sbing.com/i/products/0000/';
-const getImageUrls = (pid, iid = 1) => {
-  const paddedPid = pid.toString().padStart(6, '0');
-  // Use padded PID only for the first 3 digits
-  const prefix = paddedPid.slice(0, 3);
-  // Use the actual pid for the rest of the URL
-  const basePath = `${imageUrlBase}${prefix}/${pid}`;
-  return {
-    image: `${basePath}-t-${iid}.jpg`,
-    image_175: `${basePath}-175x175-${iid}.jpg`,
-    image_full: `${basePath}-o-${iid}.jpg`
-  };
-};
-
-// Add helper function for retrying operations with exponential backoff
-async function withRetry(operation, errorMessage) {
-  let lastError;
-  for (let attempt = 1; attempt <= MAX_RETRIES; attempt++) {
-    try {
-      return await operation();
-    } catch (error) {
-      lastError = error;
-      console.error(`${errorMessage} (Attempt ${attempt}/${MAX_RETRIES}):`, error);
-      if (attempt < MAX_RETRIES) {
-        const backoffTime = RETRY_DELAY * Math.pow(2, attempt - 1);
-        await new Promise(resolve => setTimeout(resolve, backoffTime));
-      }
-    }
-  }
-  throw lastError;
-}
-
-// Add helper function at the top of the file
-function validateDate(mysqlDate) {
-  if (!mysqlDate || mysqlDate === '0000-00-00' || mysqlDate === '0000-00-00 00:00:00') {
-    return null;
-  }
-  // Check if the date is valid
-  const date = new Date(mysqlDate);
-  return isNaN(date.getTime()) ? null : mysqlDate;
-}
-
-async function setupTemporaryTables(connection) {
-  // Drop the table if it exists
-  await connection.query('DROP TABLE IF EXISTS temp_products');
-
-  // Create the temporary table
-  await connection.query(`
-    CREATE TEMP TABLE temp_products (
-      pid BIGINT NOT NULL,
-      title VARCHAR(255),
-      description TEXT,
-      sku VARCHAR(50),
-      stock_quantity INTEGER DEFAULT 0,
-      preorder_count INTEGER DEFAULT 0,
-      notions_inv_count INTEGER DEFAULT 0,
-      price DECIMAL(10,3) NOT NULL DEFAULT 0,
-      regular_price DECIMAL(10,3) NOT NULL DEFAULT 0,
-      cost_price DECIMAL(10,3),
-      vendor VARCHAR(100),
-      vendor_reference VARCHAR(100),
-      notions_reference VARCHAR(100),
-      brand VARCHAR(100),
-      line VARCHAR(100),
-      subline VARCHAR(100),
-      artist VARCHAR(100),
-      categories TEXT,
-      created_at TIMESTAMP,
-      first_received TIMESTAMP,
-      landing_cost_price DECIMAL(10,3),
-      barcode VARCHAR(50),
-      harmonized_tariff_code VARCHAR(50),
-      updated_at TIMESTAMP,
-      visible BOOLEAN,
-      managing_stock BOOLEAN DEFAULT true,
-      replenishable BOOLEAN,
-      permalink VARCHAR(255),
-      moq INTEGER DEFAULT 1,
-      uom INTEGER DEFAULT 1,
-      rating DECIMAL(10,2),
-      reviews INTEGER,
-      weight DECIMAL(10,3),
-      length DECIMAL(10,3),
-      width DECIMAL(10,3),
-      height DECIMAL(10,3),
-      country_of_origin VARCHAR(100),
-      location VARCHAR(100),
-      total_sold INTEGER,
-      baskets INTEGER,
-      notifies INTEGER,
-      date_last_sold TIMESTAMP,
-      image VARCHAR(255),
-      image_175 VARCHAR(255),
-      image_full VARCHAR(255),
-      options TEXT,
-      tags TEXT,
-      needs_update BOOLEAN DEFAULT TRUE,
-      PRIMARY KEY (pid)
-    )`);
-
-  // Create the index
-  await connection.query('CREATE INDEX idx_temp_products_needs_update ON temp_products (needs_update)');
-}
-
-async function cleanupTemporaryTables(connection) {
-  await connection.query('DROP TABLE IF EXISTS temp_products');
-}
-
-async function importMissingProducts(prodConnection, localConnection, missingPids) {
-  if (!missingPids || missingPids.length === 0) {
-    return {
-      status: "complete",
-      recordsAdded: 0,
-      message: "No missing products to import"
-    };
-  }
-
-  try {
-    // Setup temporary tables
-    await setupTemporaryTables(localConnection);
-
-    // Get product data from production - Keep MySQL compatible
-    const [prodData] = await prodConnection.query(`
-      SELECT 
-        p.pid,
-        p.description AS title,
-        p.notes AS description,
-        p.itemnumber AS sku,
-        p.date_created,
-        p.datein AS first_received,
-        p.location,
-        p.upc AS barcode,
-        p.harmonized_tariff_code,
-        p.stamp AS updated_at,
-        CASE WHEN si.show + si.buyable > 0 THEN 1 ELSE 0 END AS visible,
-        CASE 
-          WHEN p.reorder < 0 THEN 0
-          WHEN p.date_created >= DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR) THEN 1
-          WHEN COALESCE(pnb.inventory, 0) > 0 THEN 1
-          WHEN (
-            (COALESCE(pls.date_sold, '0000-00-00') = '0000-00-00' OR pls.date_sold <= DATE_SUB(CURRENT_DATE, INTERVAL 5 YEAR))
-            AND (p.datein = '0000-00-00 00:00:00' OR p.datein <= DATE_SUB(CURRENT_TIMESTAMP, INTERVAL 5 YEAR))
-            AND (p.date_refill = '0000-00-00 00:00:00' OR p.date_refill <= DATE_SUB(CURRENT_TIMESTAMP, INTERVAL 5 YEAR))
-          ) THEN 0
-          ELSE 1
-        END AS replenishable,
-        COALESCE(si.available_local, 0) as stock_quantity,
-        0 as pending_qty,
-        COALESCE(ci.onpreorder, 0) as preorder_count,
-        COALESCE(pnb.inventory, 0) as notions_inv_count,
-        COALESCE(pcp.price_each, 0) as price,
-        COALESCE(p.sellingprice, 0) AS regular_price,
-        CASE 
-          WHEN EXISTS (SELECT 1 FROM product_inventory WHERE pid = p.pid AND count > 0) 
-          THEN (
-            SELECT ROUND(SUM(costeach * count) / SUM(count), 5) 
-            FROM product_inventory 
-            WHERE pid = p.pid AND count > 0
-          )
-          ELSE (SELECT costeach FROM product_inventory WHERE pid = p.pid ORDER BY daterec DESC LIMIT 1)
-        END AS cost_price,
-        NULL as landing_cost_price,
-        s.companyname AS vendor,
-        CASE 
-          WHEN s.companyname = 'Notions' THEN sid.notions_itemnumber 
-          ELSE sid.supplier_itemnumber 
-        END AS vendor_reference,
-        sid.notions_itemnumber AS notions_reference,
-        CONCAT('https://www.acherryontop.com/shop/product/', p.pid) AS permalink,
-        pc1.name AS brand,
-        pc2.name AS line,
-        pc3.name AS subline,
-        pc4.name AS artist,
-        COALESCE(CASE 
-          WHEN sid.supplier_id = 92 THEN sid.notions_qty_per_unit
-          ELSE sid.supplier_qty_per_unit
-        END, sid.notions_qty_per_unit) AS moq,
-        p.rating,
-        p.rating_votes AS reviews,
-        p.weight,
-        p.length,
-        p.width,
-        p.height,
-        p.country_of_origin,
-        (SELECT COUNT(*) FROM mybasket mb WHERE mb.item = p.pid AND mb.qty > 0) AS baskets,
-        (SELECT COUNT(*) FROM product_notify pn WHERE pn.pid = p.pid) AS notifies,
-        (SELECT COALESCE(SUM(oi.qty_ordered), 0) FROM order_items oi WHERE oi.prod_pid = p.pid) AS total_sold,
-        pls.date_sold as date_last_sold,
-        GROUP_CONCAT(DISTINCT CASE 
-          WHEN pc.cat_id IS NOT NULL 
-          AND pc.type IN (10, 20, 11, 21, 12, 13)
-          AND pci.cat_id NOT IN (16, 17)
-          THEN pci.cat_id 
-        END) as category_ids
-      FROM products p
-      LEFT JOIN shop_inventory si ON p.pid = si.pid AND si.store = 0
-      LEFT JOIN current_inventory ci ON p.pid = ci.pid
-      LEFT JOIN product_notions_b2b pnb ON p.pid = pnb.pid
-      LEFT JOIN product_current_prices pcp ON p.pid = pcp.pid AND pcp.active = 1
-      LEFT JOIN supplier_item_data sid ON p.pid = sid.pid
-      LEFT JOIN suppliers s ON sid.supplier_id = s.supplierid
-      LEFT JOIN product_category_index pci ON p.pid = pci.pid
-      LEFT JOIN product_categories pc ON pci.cat_id = pc.cat_id
-      LEFT JOIN product_categories pc1 ON p.company = pc1.cat_id
-      LEFT JOIN product_categories pc2 ON p.line = pc2.cat_id
-      LEFT JOIN product_categories pc3 ON p.subline = pc3.cat_id
-      LEFT JOIN product_categories pc4 ON p.artist = pc4.cat_id
-      LEFT JOIN product_last_sold pls ON p.pid = pls.pid
-      WHERE p.pid IN (?)
-      GROUP BY p.pid
-    `, [missingPids]);
-
-    if (!prodData || prodData.length === 0) {
-      return {
-        status: "complete",
-        recordsAdded: 0,
-        message: "No products found in production database"
-      };
-    }
-
-    // Process in batches
-    let recordsAdded = 0;
-    for (let i = 0; i < prodData.length; i += BATCH_SIZE) {
-      const batch = prodData.slice(i, i + BATCH_SIZE);
-      
-      const placeholders = batch.map((_, idx) => {
-        const base = idx * 47; // 47 columns
-        return `(${Array.from({ length: 47 }, (_, i) => `$${base + i + 1}`).join(', ')})`;
-      }).join(',');
-
-      const values = batch.flatMap(row => {
-        const imageUrls = getImageUrls(row.pid);
-        return [
-          row.pid,
-          row.title,
-          row.description,
-          row.sku || '',
-          row.stock_quantity > 5000 ? 0 : Math.max(0, row.stock_quantity),
-          row.preorder_count,
-          row.notions_inv_count,
-          row.price,
-          row.regular_price,
-          row.cost_price,
-          row.vendor,
-          row.vendor_reference,
-          row.notions_reference,
-          row.brand,
-          row.line,
-          row.subline,
-          row.artist,
-          row.category_ids,
-          validateDate(row.date_created),
-          validateDate(row.first_received),
-          row.landing_cost_price,
-          row.barcode,
-          row.harmonized_tariff_code,
-          validateDate(row.updated_at),
-          row.visible,
-          true,
-          row.replenishable,
-          row.permalink,
-          Math.max(1, Math.round(row.moq || 1)),
-          1,
-          row.rating,
-          row.reviews,
-          row.weight,
-          row.length,
-          row.width,
-          row.height,
-          row.country_of_origin,
-          row.location,
-          row.total_sold,
-          row.baskets,
-          row.notifies,
-          validateDate(row.date_last_sold),
-          imageUrls.image,
-          imageUrls.image_175,
-          imageUrls.image_full,
-          null,
-          null
-        ];
-      });
-
-      const [result] = await localConnection.query(`
-        WITH inserted_products AS (
-          INSERT INTO products (
-            pid, title, description, sku, stock_quantity, preorder_count, notions_inv_count,
-            price, regular_price, cost_price, vendor, vendor_reference, notions_reference,
-            brand, line, subline, artist, categories, created_at, first_received,
-            landing_cost_price, barcode, harmonized_tariff_code, updated_at, visible,
-            managing_stock, replenishable, permalink, moq, uom, rating, reviews,
-            weight, length, width, height, country_of_origin, location, total_sold,
-            baskets, notifies, date_last_sold, image, image_175, image_full, options, tags
-          )
-          VALUES ${placeholders}
-          ON CONFLICT (pid) DO NOTHING
-          RETURNING pid
-        )
-        SELECT COUNT(*) as inserted FROM inserted_products
-      `, values);
-
-      recordsAdded += parseInt(result.rows[0].inserted, 10) || 0;
-    }
-
-    return {
-      status: "complete",
-      recordsAdded,
-      message: `Successfully imported ${recordsAdded} missing products`
-    };
-  } catch (error) {
-    console.error('Error importing missing products:', error);
-    throw error;
-  }
-}
-
-async function materializeCalculations(prodConnection, localConnection, incrementalUpdate = true, lastSyncTime = '1970-01-01', startTime = Date.now()) {
-  outputProgress({
-    status: "running",
-    operation: "Products import",
-    message: "Fetching product data from production"
-  });
-
-  // Get all product data in a single optimized query - Keep MySQL compatible
-  const [prodData] = await prodConnection.query(`
-    SELECT 
-      p.pid,
-      p.description AS title,
-      p.notes AS description,
-      p.itemnumber AS sku,
-      p.date_created,
-      p.datein AS first_received,
-      p.location,
-      p.upc AS barcode,
-      p.harmonized_tariff_code,
-      p.stamp AS updated_at,
-      CASE WHEN si.show + si.buyable > 0 THEN 1 ELSE 0 END AS visible,
-      CASE 
-        WHEN p.reorder < 0 THEN 0
-        WHEN p.date_created >= DATE_SUB(CURRENT_DATE, INTERVAL 1 YEAR) THEN 1
-        WHEN COALESCE(pnb.inventory, 0) > 0 THEN 1
-        WHEN (
-          (COALESCE(pls.date_sold, '0000-00-00') = '0000-00-00' OR pls.date_sold <= DATE_SUB(CURRENT_DATE, INTERVAL 5 YEAR))
-          AND (p.datein = '0000-00-00 00:00:00' OR p.datein <= DATE_SUB(CURRENT_TIMESTAMP, INTERVAL 5 YEAR))
-          AND (p.date_refill = '0000-00-00 00:00:00' OR p.date_refill <= DATE_SUB(CURRENT_TIMESTAMP, INTERVAL 5 YEAR))
-        ) THEN 0
-        ELSE 1
-      END AS replenishable,
-      COALESCE(si.available_local, 0) as stock_quantity,
-      0 as pending_qty,
-      COALESCE(ci.onpreorder, 0) as preorder_count,
-      COALESCE(pnb.inventory, 0) as notions_inv_count,
-      COALESCE(pcp.price_each, 0) as price,
-      COALESCE(p.sellingprice, 0) AS regular_price,
-      CASE 
-        WHEN EXISTS (SELECT 1 FROM product_inventory WHERE pid = p.pid AND count > 0) 
-        THEN (
-          SELECT ROUND(SUM(costeach * count) / SUM(count), 5) 
-          FROM product_inventory 
-          WHERE pid = p.pid AND count > 0
-        )
-        ELSE (SELECT costeach FROM product_inventory WHERE pid = p.pid ORDER BY daterec DESC LIMIT 1)
-      END AS cost_price,
-      NULL as landing_cost_price,
-      s.companyname AS vendor,
-      CASE 
-        WHEN s.companyname = 'Notions' THEN sid.notions_itemnumber 
-        ELSE sid.supplier_itemnumber 
-      END AS vendor_reference,
-      sid.notions_itemnumber AS notions_reference,
-      CONCAT('https://www.acherryontop.com/shop/product/', p.pid) AS permalink,
-      pc1.name AS brand,
-      pc2.name AS line,
-      pc3.name AS subline,
-      pc4.name AS artist,
-      COALESCE(CASE 
-        WHEN sid.supplier_id = 92 THEN sid.notions_qty_per_unit
-        ELSE sid.supplier_qty_per_unit
-      END, sid.notions_qty_per_unit) AS moq,
-      p.rating,
-      p.rating_votes AS reviews,
-      p.weight,
-      p.length,
-      p.width,
-      p.height,
-      p.country_of_origin,
-      (SELECT COUNT(*) FROM mybasket mb WHERE mb.item = p.pid AND mb.qty > 0) AS baskets,
-      (SELECT COUNT(*) FROM product_notify pn WHERE pn.pid = p.pid) AS notifies,
-      (SELECT COALESCE(SUM(oi.qty_ordered), 0) FROM order_items oi WHERE oi.prod_pid = p.pid) AS total_sold,
-      pls.date_sold as date_last_sold,
-      GROUP_CONCAT(DISTINCT CASE 
-        WHEN pc.cat_id IS NOT NULL 
-        AND pc.type IN (10, 20, 11, 21, 12, 13)
-        AND pci.cat_id NOT IN (16, 17)
-        THEN pci.cat_id 
-      END) as category_ids
-    FROM products p
-    LEFT JOIN shop_inventory si ON p.pid = si.pid AND si.store = 0
-    LEFT JOIN current_inventory ci ON p.pid = ci.pid
-    LEFT JOIN product_notions_b2b pnb ON p.pid = pnb.pid
-    LEFT JOIN product_current_prices pcp ON p.pid = pcp.pid AND pcp.active = 1
-    LEFT JOIN supplier_item_data sid ON p.pid = sid.pid
-    LEFT JOIN suppliers s ON sid.supplier_id = s.supplierid
-    LEFT JOIN product_category_index pci ON p.pid = pci.pid
-    LEFT JOIN product_categories pc ON pci.cat_id = pc.cat_id
-    LEFT JOIN product_categories pc1 ON p.company = pc1.cat_id
-    LEFT JOIN product_categories pc2 ON p.line = pc2.cat_id
-    LEFT JOIN product_categories pc3 ON p.subline = pc3.cat_id
-    LEFT JOIN product_categories pc4 ON p.artist = pc4.cat_id
-    LEFT JOIN product_last_sold pls ON p.pid = pls.pid
-    WHERE ${incrementalUpdate ? `
-      p.stamp > ? OR
-      ci.stamp > ? OR
-      pcp.date_deactive > ? OR
-      pcp.date_active > ? OR
-      pnb.date_updated > ?
-    ` : 'TRUE'}
-    GROUP BY p.pid
-  `, incrementalUpdate ? [lastSyncTime, lastSyncTime, lastSyncTime, lastSyncTime, lastSyncTime] : []);
-
-  outputProgress({
-    status: "running",
-    operation: "Products import",
-    message: `Processing ${prodData.length} product records`
-  });
-
-  // Insert all product data into temp table in batches
-  for (let i = 0; i < prodData.length; i += BATCH_SIZE) {
-    const batch = prodData.slice(i, Math.min(i + BATCH_SIZE, prodData.length));
-    
-    await withRetry(async () => {
-      const placeholders = batch.map((_, idx) => {
-        const base = idx * 47; // 47 columns
-        return `(${Array.from({ length: 47 }, (_, i) => `$${base + i + 1}`).join(', ')})`;
-      }).join(',');
-
-      const values = batch.flatMap(row => {
-        const imageUrls = getImageUrls(row.pid);
-        return [
-          row.pid,
-          row.title,
-          row.description,
-          row.sku || '',
-          row.stock_quantity > 5000 ? 0 : Math.max(0, row.stock_quantity),
-          row.preorder_count,
-          row.notions_inv_count,
-          row.price,
-          row.regular_price,
-          row.cost_price,
-          row.vendor,
-          row.vendor_reference,
-          row.notions_reference,
-          row.brand,
-          row.line,
-          row.subline,
-          row.artist,
-          row.category_ids,
-          validateDate(row.date_created),
-          validateDate(row.first_received),
-          row.landing_cost_price,
-          row.barcode,
-          row.harmonized_tariff_code,
-          validateDate(row.updated_at),
-          row.visible,
-          true,
-          row.replenishable,
-          row.permalink,
-          Math.max(1, Math.round(row.moq || 1)),
-          1,
-          row.rating,
-          row.reviews,
-          row.weight,
-          row.length,
-          row.width,
-          row.height,
-          row.country_of_origin,
-          row.location,
-          row.total_sold,
-          row.baskets,
-          row.notifies,
-          validateDate(row.date_last_sold),
-          imageUrls.image,
-          imageUrls.image_175,
-          imageUrls.image_full,
-          null,
-          null
-        ];
-      });
-
-      await localConnection.query(`
-        INSERT INTO temp_products (
-          pid, title, description, sku, stock_quantity, preorder_count, notions_inv_count,
-          price, regular_price, cost_price, vendor, vendor_reference, notions_reference,
-          brand, line, subline, artist, categories, created_at, first_received,
-          landing_cost_price, barcode, harmonized_tariff_code, updated_at, visible,
-          managing_stock, replenishable, permalink, moq, uom, rating, reviews,
-          weight, length, width, height, country_of_origin, location, total_sold,
-          baskets, notifies, date_last_sold, image, image_175, image_full, options, tags
-        ) VALUES ${placeholders}
-        ON CONFLICT (pid) DO UPDATE SET
-          title = EXCLUDED.title,
-          description = EXCLUDED.description,
-          sku = EXCLUDED.sku,
-          stock_quantity = EXCLUDED.stock_quantity,
-          preorder_count = EXCLUDED.preorder_count,
-          notions_inv_count = EXCLUDED.notions_inv_count,
-          price = EXCLUDED.price,
-          regular_price = EXCLUDED.regular_price,
-          cost_price = EXCLUDED.cost_price,
-          vendor = EXCLUDED.vendor,
-          vendor_reference = EXCLUDED.vendor_reference,
-          notions_reference = EXCLUDED.notions_reference,
-          brand = EXCLUDED.brand,
-          line = EXCLUDED.line,
-          subline = EXCLUDED.subline,
-          artist = EXCLUDED.artist,
-          created_at = EXCLUDED.created_at,
-          first_received = EXCLUDED.first_received,
-          landing_cost_price = EXCLUDED.landing_cost_price,
-          barcode = EXCLUDED.barcode,
-          harmonized_tariff_code = EXCLUDED.harmonized_tariff_code,
-          updated_at = EXCLUDED.updated_at,
-          visible = EXCLUDED.visible,
-          managing_stock = EXCLUDED.managing_stock,
-          replenishable = EXCLUDED.replenishable,
-          permalink = EXCLUDED.permalink,
-          moq = EXCLUDED.moq,
-          uom = EXCLUDED.uom,
-          rating = EXCLUDED.rating,
-          reviews = EXCLUDED.reviews,
-          weight = EXCLUDED.weight,
-          length = EXCLUDED.length,
-          width = EXCLUDED.width,
-          height = EXCLUDED.height,
-          country_of_origin = EXCLUDED.country_of_origin,
-          location = EXCLUDED.location,
-          total_sold = EXCLUDED.total_sold,
-          baskets = EXCLUDED.baskets,
-          notifies = EXCLUDED.notifies,
-          date_last_sold = EXCLUDED.date_last_sold,
-          image = EXCLUDED.image,
-          image_175 = EXCLUDED.image_175,
-          image_full = EXCLUDED.image_full,
-          options = EXCLUDED.options,
-          tags = EXCLUDED.tags
-        RETURNING 
-          xmax = 0 as inserted
-      `, values);
-    }, `Error inserting batch ${i} to ${i + batch.length}`);
-
-    outputProgress({
-      status: "running",
-      operation: "Products import",
-      message: `Imported ${i + batch.length} of ${prodData.length} products`,
-      current: i + batch.length,
-      total: prodData.length,
-      elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
-      remaining: estimateRemaining(startTime, i + batch.length, prodData.length),
-      rate: calculateRate(startTime, i + batch.length)
-    });
-  }
-
-  outputProgress({
-    status: "running",
-    operation: "Products import",
-    message: "Finished materializing calculations"
-  });
-}
-
-async function importProducts(prodConnection, localConnection, incrementalUpdate = true) {
-  const startTime = Date.now();
-  let lastSyncTime = '1970-01-01';
-
-  try {
-    // Get last sync time if doing incremental update
-    if (incrementalUpdate) {
-      const [syncResult] = await localConnection.query(
-        "SELECT last_sync_timestamp FROM sync_status WHERE table_name = 'products'"
-      );
-      if (syncResult.rows.length > 0) {
-        lastSyncTime = syncResult.rows[0].last_sync_timestamp;
-      }
-    }
-
-    // Start a transaction to ensure temporary tables persist
-    await localConnection.beginTransaction();
-
-    try {
-      // Setup temporary tables
-      await setupTemporaryTables(localConnection);
-
-      // Materialize calculations into temp table
-      await materializeCalculations(prodConnection, localConnection, incrementalUpdate, lastSyncTime, startTime);
-
-      // Get the list of products that need updating
-      const [products] = await localConnection.query(`
-        SELECT 
-          t.pid,
-          t.title,
-          t.description,
-          t.sku,
-          t.stock_quantity,
-          t.preorder_count,
-          t.notions_inv_count,
-          t.price,
-          t.regular_price,
-          t.cost_price,
-          t.vendor,
-          t.vendor_reference,
-          t.notions_reference,
-          t.brand,
-          t.line,
-          t.subline,
-          t.artist,
-          t.categories,
-          t.created_at,
-          t.first_received,
-          t.landing_cost_price,
-          t.barcode,
-          t.harmonized_tariff_code,
-          t.updated_at,
-          t.visible,
-          t.managing_stock,
-          t.replenishable,
-          t.permalink,
-          t.moq,
-          t.rating,
-          t.reviews,
-          t.weight,
-          t.length,
-          t.width,
-          t.height,
-          t.country_of_origin,
-          t.location,
-          t.total_sold,
-          t.baskets,
-          t.notifies,
-          t.date_last_sold,
-          t.image,
-          t.image_175,
-          t.image_full,
-          t.options,
-          t.tags
-        FROM temp_products t
-        WHERE t.needs_update = true
-      `);
-
-      // Process products in batches
-      let recordsAdded = 0;
-      let recordsUpdated = 0;
-
-      for (let i = 0; i < products.rows.length; i += BATCH_SIZE) {
-        const batch = products.rows.slice(i, i + BATCH_SIZE);
-        
-        const placeholders = batch.map((_, idx) => {
-          const base = idx * 47; // 47 columns
-          return `(${Array.from({ length: 47 }, (_, i) => `$${base + i + 1}`).join(', ')})`;
-        }).join(',');
-
-        const values = batch.flatMap(row => {
-          const imageUrls = getImageUrls(row.pid);
-          return [
-            row.pid,
-            row.title,
-            row.description,
-            row.sku || '',
-            row.stock_quantity > 5000 ? 0 : Math.max(0, row.stock_quantity),
-            row.preorder_count,
-            row.notions_inv_count,
-            row.price,
-            row.regular_price,
-            row.cost_price,
-            row.vendor,
-            row.vendor_reference,
-            row.notions_reference,
-            row.brand,
-            row.line,
-            row.subline,
-            row.artist,
-            row.categories,
-            validateDate(row.created_at),
-            validateDate(row.first_received),
-            row.landing_cost_price,
-            row.barcode,
-            row.harmonized_tariff_code,
-            validateDate(row.updated_at),
-            row.visible,
-            row.managing_stock,
-            row.replenishable,
-            row.permalink,
-            row.moq,
-            1,
-            row.rating,
-            row.reviews,
-            row.weight,
-            row.length,
-            row.width,
-            row.height,
-            row.country_of_origin,
-            row.location,
-            row.total_sold,
-            row.baskets,
-            row.notifies,
-            validateDate(row.date_last_sold),
-            imageUrls.image,
-            imageUrls.image_175,
-            imageUrls.image_full,
-            row.options,
-            row.tags
-          ];
-        });
-
-        const [result] = await localConnection.query(`
-          WITH upserted AS (
-            INSERT INTO products (
-              pid, title, description, sku, stock_quantity, preorder_count, notions_inv_count,
-              price, regular_price, cost_price, vendor, vendor_reference, notions_reference,
-              brand, line, subline, artist, categories, created_at, first_received,
-              landing_cost_price, barcode, harmonized_tariff_code, updated_at, visible,
-              managing_stock, replenishable, permalink, moq, uom, rating, reviews,
-              weight, length, width, height, country_of_origin, location, total_sold,
-              baskets, notifies, date_last_sold, image, image_175, image_full, options, tags
-            )
-            VALUES ${placeholders}
-            ON CONFLICT (pid) DO UPDATE SET
-              title = EXCLUDED.title,
-              description = EXCLUDED.description,
-              sku = EXCLUDED.sku,
-              stock_quantity = EXCLUDED.stock_quantity,
-              preorder_count = EXCLUDED.preorder_count,
-              notions_inv_count = EXCLUDED.notions_inv_count,
-              price = EXCLUDED.price,
-              regular_price = EXCLUDED.regular_price,
-              cost_price = EXCLUDED.cost_price,
-              vendor = EXCLUDED.vendor,
-              vendor_reference = EXCLUDED.vendor_reference,
-              notions_reference = EXCLUDED.notions_reference,
-              brand = EXCLUDED.brand,
-              line = EXCLUDED.line,
-              subline = EXCLUDED.subline,
-              artist = EXCLUDED.artist,
-              created_at = EXCLUDED.created_at,
-              first_received = EXCLUDED.first_received,
-              landing_cost_price = EXCLUDED.landing_cost_price,
-              barcode = EXCLUDED.barcode,
-              harmonized_tariff_code = EXCLUDED.harmonized_tariff_code,
-              updated_at = EXCLUDED.updated_at,
-              visible = EXCLUDED.visible,
-              managing_stock = EXCLUDED.managing_stock,
-              replenishable = EXCLUDED.replenishable,
-              permalink = EXCLUDED.permalink,
-              moq = EXCLUDED.moq,
-              uom = EXCLUDED.uom,
-              rating = EXCLUDED.rating,
-              reviews = EXCLUDED.reviews,
-              weight = EXCLUDED.weight,
-              length = EXCLUDED.length,
-              width = EXCLUDED.width,
-              height = EXCLUDED.height,
-              country_of_origin = EXCLUDED.country_of_origin,
-              location = EXCLUDED.location,
-              total_sold = EXCLUDED.total_sold,
-              baskets = EXCLUDED.baskets,
-              notifies = EXCLUDED.notifies,
-              date_last_sold = EXCLUDED.date_last_sold,
-              image = EXCLUDED.image,
-              image_175 = EXCLUDED.image_175,
-              image_full = EXCLUDED.image_full,
-              options = EXCLUDED.options,
-              tags = EXCLUDED.tags
-            RETURNING 
-              xmax = 0 as inserted
-          )
-          SELECT 
-            COUNT(*) FILTER (WHERE inserted) as inserted,
-            COUNT(*) FILTER (WHERE NOT inserted) as updated
-          FROM upserted
-        `, values);
-
-        recordsAdded += parseInt(result.rows[0].inserted, 10) || 0;
-        recordsUpdated += parseInt(result.rows[0].updated, 10) || 0;
-
-        // Process category relationships in batches
-        const allCategories = [];
-        for (const row of batch) {
-          if (row.categories) {
-            const categoryIds = row.categories.split(',').filter(id => id && id.trim());
-            if (categoryIds.length > 0) {
-              categoryIds.forEach(catId => {
-                allCategories.push([row.pid, parseInt(catId.trim(), 10)]);
-              });
-            }
-          }
-        }
-
-        // If we have categories to process
-        if (allCategories.length > 0) {
-          // First get all products in this batch
-          const productIds = batch.map(p => p.pid);
-          
-          // Delete all existing relationships for products in this batch
-          await localConnection.query(
-            'DELETE FROM product_categories WHERE pid = ANY($1)',
-            [productIds]
-          );
-          
-          // Insert all new relationships in one batch
-          const catPlaceholders = allCategories.map((_, idx) => 
-            `($${idx * 2 + 1}, $${idx * 2 + 2})`
-          ).join(',');
-          
-          const catValues = allCategories.flat();
-          
-          await localConnection.query(`
-            INSERT INTO product_categories (pid, cat_id)
-            VALUES ${catPlaceholders}
-            ON CONFLICT (pid, cat_id) DO NOTHING
-          `, catValues);
-        }
-
-        outputProgress({
-          status: "running",
-          operation: "Products import",
-          message: `Processing products: ${i + batch.length} of ${products.rows.length}`,
-          current: i + batch.length,
-          total: products.rows.length,
-          elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
-          remaining: estimateRemaining(startTime, i + batch.length, products.rows.length),
-          rate: calculateRate(startTime, i + batch.length)
-        });
-      }
-
-      // Cleanup temporary tables
-      await cleanupTemporaryTables(localConnection);
-
-      // Commit the transaction
-      await localConnection.commit();
-
-      // Update sync status
-      await localConnection.query(`
-        INSERT INTO sync_status (table_name, last_sync_timestamp)
-        VALUES ('products', NOW())
-        ON CONFLICT (table_name) DO UPDATE SET
-          last_sync_timestamp = NOW()
-      `);
-
-      return {
-        status: 'complete',
-        recordsAdded,
-        recordsUpdated,
-        totalRecords: products.rows.length,
-        duration: formatElapsedTime(Date.now() - startTime)
-      };
-    } catch (error) {
-      // Rollback on error
-      await localConnection.rollback();
-      throw error;
-    }
-  } catch (error) {
-    console.error('Error in importProducts:', error);
-    throw error;
-  }
-}
-
-module.exports = {
-  importProducts,
-  importMissingProducts,
-  setupTemporaryTables,
-  cleanupTemporaryTables,
-  materializeCalculations
-};

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

@@ -1,967 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate } = require('../metrics/utils/progress');
-
-/**
- * Validates a date from MySQL before inserting it into PostgreSQL
- * @param {string|Date|null} mysqlDate - Date string or object from MySQL
- * @returns {string|null} Valid date string or null if invalid
- */
-function validateDate(mysqlDate) {
-  // Handle null, undefined, or empty values
-  if (!mysqlDate) {
-    return null;
-  }
-  
-  // Convert to string if it's not already
-  const dateStr = String(mysqlDate);
-  
-  // Handle MySQL zero dates and empty values
-  if (dateStr === '0000-00-00' || 
-      dateStr === '0000-00-00 00:00:00' ||
-      dateStr.indexOf('0000-00-00') !== -1 ||
-      dateStr === '') {
-    return null;
-  }
-  
-  // Check if the date is valid
-  const date = new Date(mysqlDate);
-  
-  // If the date is invalid or suspiciously old (pre-1970), return null
-  if (isNaN(date.getTime()) || date.getFullYear() < 1970) {
-    return null;
-  }
-  
-  return mysqlDate;
-}
-
-/**
- * Imports purchase orders and receivings from a production MySQL database to a local PostgreSQL database.
- * Implements FIFO allocation of receivings to purchase orders.
- * 
- * @param {object} prodConnection - A MySQL connection to production DB
- * @param {object} localConnection - A PostgreSQL connection to local DB
- * @param {boolean} incrementalUpdate - Set to false for a full sync; true for incremental
- * @returns {object} Information about the sync operation
- */
-async function importPurchaseOrders(prodConnection, localConnection, incrementalUpdate = true) {
-  const startTime = Date.now();
-  let recordsAdded = 0;
-  let recordsUpdated = 0;
-  let totalProcessed = 0;
-  
-  // Batch size constants
-  const PO_BATCH_SIZE = 500;
-  const INSERT_BATCH_SIZE = 100;
-
-  try {
-    // Begin transaction for the entire import process
-    await localConnection.beginTransaction();
-
-    // Get last sync info
-    const [syncInfo] = await localConnection.query(
-      "SELECT last_sync_timestamp FROM sync_status WHERE table_name = 'purchase_orders'"
-    );
-    const lastSyncTime = syncInfo?.rows?.[0]?.last_sync_timestamp || '1970-01-01';
-
-    console.log('Purchase Orders: Using last sync time:', lastSyncTime);
-
-    // Create temp tables for processing
-    await localConnection.query(`
-      DROP TABLE IF EXISTS temp_purchase_orders;
-      DROP TABLE IF EXISTS temp_receivings;
-      DROP TABLE IF EXISTS temp_receiving_allocations;
-      DROP TABLE IF EXISTS employee_names;
-      
-      -- Temporary table for purchase orders
-      CREATE TEMP TABLE temp_purchase_orders (
-        po_id VARCHAR(50) NOT NULL,
-        pid BIGINT NOT NULL,
-        sku VARCHAR(50),
-        name VARCHAR(255),
-        vendor VARCHAR(255),
-        date TIMESTAMP WITH TIME ZONE,
-        expected_date DATE,
-        status INTEGER,
-        status_text VARCHAR(50),
-        notes TEXT,
-        long_note TEXT,
-        ordered INTEGER,
-        po_cost_price DECIMAL(10,3),
-        supplier_id INTEGER,
-        date_created TIMESTAMP WITH TIME ZONE,
-        date_ordered TIMESTAMP WITH TIME ZONE,
-        PRIMARY KEY (po_id, pid)
-      );
-      
-      -- Temporary table for receivings
-      CREATE TEMP TABLE temp_receivings (
-        receiving_id VARCHAR(50) NOT NULL,
-        po_id VARCHAR(50),
-        pid BIGINT NOT NULL,
-        qty_each INTEGER,
-        cost_each DECIMAL(10,5),
-        received_by INTEGER,
-        received_date TIMESTAMP WITH TIME ZONE,
-        receiving_created_date TIMESTAMP WITH TIME ZONE,
-        supplier_id INTEGER,
-        status INTEGER,
-        status_text VARCHAR(50),
-        PRIMARY KEY (receiving_id, pid)
-      );
-      
-      -- Temporary table for tracking FIFO allocations
-      CREATE TEMP TABLE temp_receiving_allocations (
-        po_id VARCHAR(50) NOT NULL,
-        pid BIGINT NOT NULL,
-        receiving_id VARCHAR(50) NOT NULL,
-        allocated_qty INTEGER NOT NULL,
-        cost_each DECIMAL(10,5) NOT NULL,
-        received_date TIMESTAMP WITH TIME ZONE NOT NULL,
-        received_by INTEGER,
-        PRIMARY KEY (po_id, pid, receiving_id)
-      );
-      
-      -- Temporary table for employee names
-      CREATE TEMP TABLE employee_names (
-        employeeid INTEGER PRIMARY KEY,
-        firstname VARCHAR(100),
-        lastname VARCHAR(100)
-      );
-      
-      -- Create indexes for efficient joins
-      CREATE INDEX idx_temp_po_pid ON temp_purchase_orders(pid);
-      CREATE INDEX idx_temp_receiving_pid ON temp_receivings(pid);
-      CREATE INDEX idx_temp_receiving_po_id ON temp_receivings(po_id);
-    `);
-
-    // Map status codes to text values
-    const poStatusMap = {
-      0: 'Canceled',
-      1: 'Created',
-      10: 'Ready ESend',
-      11: 'Ordered',
-      12: 'Preordered',
-      13: 'Electronically Sent',
-      15: 'Receiving Started',
-      50: 'Done'
-    };
-    
-    const receivingStatusMap = {
-      0: 'Canceled',
-      1: 'Created',
-      30: 'Partial Received',
-      40: 'Full Received',
-      50: 'Paid'
-    };
-
-    // Get time window for data retrieval
-    const yearInterval = incrementalUpdate ? 1 : 5;
-
-    // Fetch employee data from production
-    outputProgress({
-      status: "running",
-      operation: "Purchase orders import",
-      message: "Fetching employee data"
-    });
-
-    const [employees] = await prodConnection.query(`
-      SELECT 
-        employeeid,
-        firstname,
-        lastname
-      FROM employees
-    `);
-
-    // Insert employee data into temp table
-    if (employees.length > 0) {
-      const employeeValues = employees.map(emp => [
-        emp.employeeid,
-        emp.firstname || '',
-        emp.lastname || ''
-      ]).flat();
-
-      const placeholders = employees.map((_, idx) => {
-        const base = idx * 3;
-        return `($${base + 1}, $${base + 2}, $${base + 3})`;
-      }).join(',');
-
-      await localConnection.query(`
-        INSERT INTO employee_names (employeeid, firstname, lastname)
-        VALUES ${placeholders}
-        ON CONFLICT (employeeid) DO UPDATE SET
-          firstname = EXCLUDED.firstname,
-          lastname = EXCLUDED.lastname
-      `, employeeValues);
-    }
-
-    // 1. First, fetch all relevant POs
-    outputProgress({
-      status: "running",
-      operation: "Purchase orders import",
-      message: "Fetching purchase orders"
-    });
-
-    const [poCount] = await prodConnection.query(`
-      SELECT COUNT(*) as total
-      FROM po p
-      WHERE p.date_created >= DATE_SUB(CURRENT_DATE, INTERVAL ${yearInterval} YEAR)
-        ${incrementalUpdate ? `
-          AND (
-            p.date_updated > ? 
-            OR p.date_ordered > ? 
-            OR p.date_estin > ?
-          )
-        ` : ''}
-    `, incrementalUpdate ? [lastSyncTime, lastSyncTime, lastSyncTime] : []);
-
-    const totalPOs = poCount[0].total;
-    console.log(`Found ${totalPOs} relevant purchase orders`);
-
-    // Fetch and process POs in batches
-    let offset = 0;
-    let allPOsProcessed = false;
-    
-    while (!allPOsProcessed) {
-      const [poList] = await prodConnection.query(`
-        SELECT 
-          p.po_id,
-          p.supplier_id,
-          s.companyname AS vendor,
-          p.status,
-          p.notes AS long_note,
-          p.short_note AS notes,
-          p.date_created,
-          p.date_ordered,
-          p.date_estin
-        FROM po p
-        LEFT JOIN suppliers s ON p.supplier_id = s.supplierid
-        WHERE p.date_created >= DATE_SUB(CURRENT_DATE, INTERVAL ${yearInterval} YEAR)
-          ${incrementalUpdate ? `
-            AND (
-              p.date_updated > ? 
-              OR p.date_ordered > ? 
-              OR p.date_estin > ?
-            )
-          ` : ''}
-        ORDER BY p.po_id
-        LIMIT ${PO_BATCH_SIZE} OFFSET ${offset}
-      `, incrementalUpdate ? [lastSyncTime, lastSyncTime, lastSyncTime] : []);
-      
-      if (poList.length === 0) {
-        allPOsProcessed = true;
-        break;
-      }
-      
-      // Get products for these POs
-      const poIds = poList.map(po => po.po_id);
-      
-      const [poProducts] = await prodConnection.query(`
-        SELECT 
-          pp.po_id,
-          pp.pid,
-          pp.qty_each,
-          pp.cost_each,
-          COALESCE(p.itemnumber, 'NO-SKU') AS sku,
-          COALESCE(p.description, 'Unknown Product') AS name
-        FROM po_products pp
-        LEFT JOIN products p ON pp.pid = p.pid
-        WHERE pp.po_id IN (?)
-      `, [poIds]);
-      
-      // Build complete PO records
-      const completePOs = [];
-      for (const product of poProducts) {
-        const po = poList.find(p => p.po_id == product.po_id);
-        if (!po) continue;
-        
-        completePOs.push({
-          po_id: po.po_id.toString(),
-          pid: product.pid,
-          sku: product.sku,
-          name: product.name,
-          vendor: po.vendor || 'Unknown Vendor',
-          date: validateDate(po.date_ordered) || validateDate(po.date_created),
-          expected_date: validateDate(po.date_estin),
-          status: po.status,
-          status_text: poStatusMap[po.status] || '',
-          notes: po.notes || '',
-          long_note: po.long_note || '',
-          ordered: product.qty_each,
-          po_cost_price: product.cost_each,
-          supplier_id: po.supplier_id,
-          date_created: validateDate(po.date_created),
-          date_ordered: validateDate(po.date_ordered)
-        });
-      }
-      
-      // Insert PO data in batches
-      for (let i = 0; i < completePOs.length; i += INSERT_BATCH_SIZE) {
-        const batch = completePOs.slice(i, i + INSERT_BATCH_SIZE);
-        
-        const placeholders = batch.map((_, idx) => {
-          const base = idx * 16;
-          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}, $${base + 15}, $${base + 16})`;
-        }).join(',');
-        
-        const values = batch.flatMap(po => [
-          po.po_id,
-          po.pid,
-          po.sku,
-          po.name,
-          po.vendor,
-          po.date,
-          po.expected_date,
-          po.status,
-          po.status_text,
-          po.notes,
-          po.long_note,
-          po.ordered,
-          po.po_cost_price,
-          po.supplier_id,
-          po.date_created,
-          po.date_ordered
-        ]);
-        
-        await localConnection.query(`
-          INSERT INTO temp_purchase_orders (
-            po_id, pid, sku, name, vendor, date, expected_date, status, status_text,
-            notes, long_note, ordered, po_cost_price, supplier_id, date_created, date_ordered
-          )
-          VALUES ${placeholders}
-          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,
-            status_text = EXCLUDED.status_text,
-            notes = EXCLUDED.notes,
-            long_note = EXCLUDED.long_note,
-            ordered = EXCLUDED.ordered,
-            po_cost_price = EXCLUDED.po_cost_price,
-            supplier_id = EXCLUDED.supplier_id,
-            date_created = EXCLUDED.date_created,
-            date_ordered = EXCLUDED.date_ordered
-        `, values);
-      }
-      
-      offset += poList.length;
-      totalProcessed += completePOs.length;
-      
-      outputProgress({
-        status: "running",
-        operation: "Purchase orders import",
-        message: `Processed ${offset} of ${totalPOs} purchase orders (${totalProcessed} line items)`,
-        current: offset,
-        total: totalPOs,
-        elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
-        remaining: estimateRemaining(startTime, offset, totalPOs),
-        rate: calculateRate(startTime, offset)
-      });
-      
-      if (poList.length < PO_BATCH_SIZE) {
-        allPOsProcessed = true;
-      }
-    }
-    
-    // 2. Next, fetch all relevant receivings
-    outputProgress({
-      status: "running",
-      operation: "Purchase orders import",
-      message: "Fetching receivings data"
-    });
-
-    const [receivingCount] = await prodConnection.query(`
-      SELECT COUNT(*) as total
-      FROM receivings r
-      WHERE r.date_created >= DATE_SUB(CURRENT_DATE, INTERVAL ${yearInterval} YEAR)
-        ${incrementalUpdate ? `
-          AND (
-            r.date_updated > ?
-            OR r.date_created > ?
-          )
-        ` : ''}
-    `, incrementalUpdate ? [lastSyncTime, lastSyncTime] : []);
-
-    const totalReceivings = receivingCount[0].total;
-    console.log(`Found ${totalReceivings} relevant receivings`);
-
-    // Fetch and process receivings in batches
-    offset = 0; // Reset offset for receivings
-    let allReceivingsProcessed = false;
-    
-    while (!allReceivingsProcessed) {
-      const [receivingList] = await prodConnection.query(`
-        SELECT 
-          r.receiving_id,
-          r.po_id,
-          r.supplier_id,
-          r.status,
-          r.date_created
-        FROM receivings r
-        WHERE r.date_created >= DATE_SUB(CURRENT_DATE, INTERVAL ${yearInterval} YEAR)
-          ${incrementalUpdate ? `
-            AND (
-              r.date_updated > ?
-              OR r.date_created > ?
-            )
-          ` : ''}
-        ORDER BY r.receiving_id
-        LIMIT ${PO_BATCH_SIZE} OFFSET ${offset}
-      `, incrementalUpdate ? [lastSyncTime, lastSyncTime] : []);
-      
-      if (receivingList.length === 0) {
-        allReceivingsProcessed = true;
-        break;
-      }
-      
-      // Get products for these receivings
-      const receivingIds = receivingList.map(r => r.receiving_id);
-      
-      const [receivingProducts] = await prodConnection.query(`
-        SELECT 
-          rp.receiving_id,
-          rp.pid,
-          rp.qty_each,
-          rp.cost_each,
-          rp.received_by,
-          rp.received_date,
-          r.date_created as receiving_created_date
-        FROM receivings_products rp
-        JOIN receivings r ON rp.receiving_id = r.receiving_id
-        WHERE rp.receiving_id IN (?)
-      `, [receivingIds]);
-      
-      // Build complete receiving records
-      const completeReceivings = [];
-      for (const product of receivingProducts) {
-        const receiving = receivingList.find(r => r.receiving_id == product.receiving_id);
-        if (!receiving) continue;
-        
-        completeReceivings.push({
-          receiving_id: receiving.receiving_id.toString(),
-          po_id: receiving.po_id ? receiving.po_id.toString() : null,
-          pid: product.pid,
-          qty_each: product.qty_each,
-          cost_each: product.cost_each,
-          received_by: product.received_by,
-          received_date: validateDate(product.received_date) || validateDate(product.receiving_created_date),
-          receiving_created_date: validateDate(product.receiving_created_date),
-          supplier_id: receiving.supplier_id,
-          status: receiving.status,
-          status_text: receivingStatusMap[receiving.status] || '',
-          receiving_created_date: validateDate(product.receiving_created_date)
-        });
-      }
-      
-      // Insert receiving data in batches
-      for (let i = 0; i < completeReceivings.length; i += INSERT_BATCH_SIZE) {
-        const batch = completeReceivings.slice(i, i + INSERT_BATCH_SIZE);
-        
-        const placeholders = batch.map((_, idx) => {
-          const base = idx * 11;
-          return `($${base + 1}, $${base + 2}, $${base + 3}, $${base + 4}, $${base + 5}, $${base + 6}, $${base + 7}, $${base + 8}, $${base + 9}, $${base + 10}, $${base + 11})`;
-        }).join(',');
-        
-        const values = batch.flatMap(r => [
-          r.receiving_id,
-          r.po_id,
-          r.pid,
-          r.qty_each,
-          r.cost_each,
-          r.received_by,
-          r.received_date,
-          r.receiving_created_date,
-          r.supplier_id,
-          r.status,
-          r.status_text
-        ]);
-        
-        await localConnection.query(`
-          INSERT INTO temp_receivings (
-            receiving_id, po_id, pid, qty_each, cost_each, received_by,
-            received_date, receiving_created_date, supplier_id, status, status_text
-          )
-          VALUES ${placeholders}
-          ON CONFLICT (receiving_id, pid) DO UPDATE SET
-            po_id = EXCLUDED.po_id,
-            qty_each = EXCLUDED.qty_each,
-            cost_each = EXCLUDED.cost_each,
-            received_by = EXCLUDED.received_by,
-            received_date = EXCLUDED.received_date,
-            receiving_created_date = EXCLUDED.receiving_created_date,
-            supplier_id = EXCLUDED.supplier_id,
-            status = EXCLUDED.status,
-            status_text = EXCLUDED.status_text
-        `, values);
-      }
-      
-      offset += receivingList.length;
-      totalProcessed += completeReceivings.length;
-      
-      outputProgress({
-        status: "running",
-        operation: "Purchase orders import",
-        message: `Processed ${offset} of ${totalReceivings} receivings (${totalProcessed} line items total)`,
-        current: offset,
-        total: totalReceivings,
-        elapsed: formatElapsedTime((Date.now() - startTime) / 1000),
-        remaining: estimateRemaining(startTime, offset, totalReceivings),
-        rate: calculateRate(startTime, offset)
-      });
-      
-      if (receivingList.length < PO_BATCH_SIZE) {
-        allReceivingsProcessed = true;
-      }
-    }
-
-    // 3. Implement FIFO allocation of receivings to purchase orders
-    outputProgress({
-      status: "running",
-      operation: "Purchase orders import",
-      message: "Validating product IDs before allocation"
-    });
-
-    // Add this section to filter out invalid PIDs before allocation
-    // This will check all PIDs in our temp tables against the products table
-    await localConnection.query(`
-      -- Create temp table to store invalid PIDs
-      DROP TABLE IF EXISTS temp_invalid_pids;
-      CREATE TEMP TABLE temp_invalid_pids AS (
-        -- Get all unique PIDs from our temp tables
-        WITH all_pids AS (
-          SELECT DISTINCT pid FROM temp_purchase_orders
-          UNION
-          SELECT DISTINCT pid FROM temp_receivings
-        )
-        -- Filter to only those that don't exist in products table
-        SELECT p.pid
-        FROM all_pids p
-        WHERE NOT EXISTS (
-          SELECT 1 FROM products WHERE pid = p.pid
-        )
-      );
-      
-      -- Remove purchase orders with invalid PIDs
-      DELETE FROM temp_purchase_orders
-      WHERE pid IN (SELECT pid FROM temp_invalid_pids);
-      
-      -- Remove receivings with invalid PIDs
-      DELETE FROM temp_receivings
-      WHERE pid IN (SELECT pid FROM temp_invalid_pids);
-    `);
-
-    // Get count of filtered items for reporting
-    const [filteredResult] = await localConnection.query(`
-      SELECT COUNT(*) as count FROM temp_invalid_pids
-    `);
-    const filteredCount = filteredResult.rows[0].count;
-
-    if (filteredCount > 0) {
-      console.log(`Filtered out ${filteredCount} items with invalid product IDs`);
-    }
-
-    // Break FIFO allocation into steps with progress tracking
-    const fifoSteps = [
-      {
-        name: "Direct allocations",
-        query: `
-          INSERT INTO temp_receiving_allocations (
-            po_id, pid, receiving_id, allocated_qty, cost_each, received_date, received_by
-          )
-          SELECT 
-            r.po_id,
-            r.pid,
-            r.receiving_id,
-            LEAST(r.qty_each, po.ordered) as allocated_qty,
-            r.cost_each,
-            COALESCE(r.received_date, NOW()) as received_date,
-            r.received_by
-          FROM temp_receivings r
-          JOIN temp_purchase_orders po ON r.po_id = po.po_id AND r.pid = po.pid
-          WHERE r.po_id IS NOT NULL
-        `
-      },
-      {
-        name: "Handling standalone receivings",
-        query: `
-          INSERT INTO temp_purchase_orders (
-            po_id, pid, sku, name, vendor, date, status, status_text, 
-            ordered, po_cost_price, supplier_id, date_created, date_ordered
-          )
-          SELECT 
-            'R' || r.receiving_id as po_id,
-            r.pid,
-            COALESCE(p.sku, 'NO-SKU') as sku,
-            COALESCE(p.name, 'Unknown Product') as name,
-            COALESCE(
-              (SELECT vendor FROM temp_purchase_orders 
-               WHERE supplier_id = r.supplier_id LIMIT 1),
-              'Unknown Vendor'
-            ) as vendor,
-            COALESCE(r.received_date, r.receiving_created_date) as date,
-            NULL as status,
-            NULL as status_text,
-            NULL as ordered,
-            r.cost_each as po_cost_price,
-            r.supplier_id,
-            COALESCE(r.receiving_created_date, r.received_date) as date_created,
-            NULL as date_ordered
-          FROM temp_receivings r
-          LEFT JOIN (
-            SELECT DISTINCT pid, sku, name FROM temp_purchase_orders
-          ) p ON r.pid = p.pid
-          WHERE r.po_id IS NULL 
-          OR NOT EXISTS (
-            SELECT 1 FROM temp_purchase_orders po 
-            WHERE po.po_id = r.po_id AND po.pid = r.pid
-          )
-          ON CONFLICT (po_id, pid) DO NOTHING
-        `
-      },
-      {
-        name: "Allocating standalone receivings",
-        query: `
-          INSERT INTO temp_receiving_allocations (
-            po_id, pid, receiving_id, allocated_qty, cost_each, received_date, received_by
-          )
-          SELECT 
-            'R' || r.receiving_id as po_id,
-            r.pid,
-            r.receiving_id,
-            r.qty_each as allocated_qty,
-            r.cost_each,
-            COALESCE(r.received_date, NOW()) as received_date,
-            r.received_by
-          FROM temp_receivings r
-          WHERE r.po_id IS NULL
-          OR NOT EXISTS (
-            SELECT 1 FROM temp_purchase_orders po 
-            WHERE po.po_id = r.po_id AND po.pid = r.pid
-          )
-        `
-      },
-      {
-        name: "FIFO allocation logic",
-        query: `
-          WITH 
-          -- Calculate remaining quantities after direct allocations
-          remaining_po_quantities AS (
-            SELECT 
-              po.po_id,
-              po.pid,
-              po.ordered,
-              COALESCE(SUM(ra.allocated_qty), 0) as already_allocated,
-              po.ordered - COALESCE(SUM(ra.allocated_qty), 0) as remaining_qty,
-              po.date_ordered,
-              po.date_created
-            FROM temp_purchase_orders po
-            LEFT JOIN temp_receiving_allocations ra ON po.po_id = ra.po_id AND po.pid = ra.pid
-            WHERE po.ordered IS NOT NULL
-            GROUP BY po.po_id, po.pid, po.ordered, po.date_ordered, po.date_created
-            HAVING po.ordered > COALESCE(SUM(ra.allocated_qty), 0)
-          ),
-          remaining_receiving_quantities AS (
-            SELECT 
-              r.receiving_id,
-              r.pid,
-              r.qty_each,
-              COALESCE(SUM(ra.allocated_qty), 0) as already_allocated,
-              r.qty_each - COALESCE(SUM(ra.allocated_qty), 0) as remaining_qty,
-              r.received_date,
-              r.cost_each,
-              r.received_by
-            FROM temp_receivings r
-            LEFT JOIN temp_receiving_allocations ra ON r.receiving_id = ra.receiving_id AND r.pid = ra.pid
-            GROUP BY r.receiving_id, r.pid, r.qty_each, r.received_date, r.cost_each, r.received_by
-            HAVING r.qty_each > COALESCE(SUM(ra.allocated_qty), 0)
-          ),
-          -- Rank POs by age, with a cutoff for very old POs (1 year)
-          ranked_pos AS (
-            SELECT 
-              po.po_id,
-              po.pid,
-              po.remaining_qty,
-              CASE 
-                WHEN po.date_ordered IS NULL OR po.date_ordered < NOW() - INTERVAL '1 year' THEN 2
-                ELSE 1
-              END as age_group,
-              ROW_NUMBER() OVER (
-                PARTITION BY po.pid, (CASE WHEN po.date_ordered IS NULL OR po.date_ordered < NOW() - INTERVAL '1 year' THEN 2 ELSE 1 END)
-                ORDER BY COALESCE(po.date_ordered, po.date_created, NOW())
-              ) as rank_in_group
-            FROM remaining_po_quantities po
-          ),
-          -- Rank receivings by date
-          ranked_receivings AS (
-            SELECT 
-              r.receiving_id,
-              r.pid,
-              r.remaining_qty,
-              r.received_date,
-              r.cost_each,
-              r.received_by,
-              ROW_NUMBER() OVER (PARTITION BY r.pid ORDER BY COALESCE(r.received_date, NOW())) as rank
-            FROM remaining_receiving_quantities r
-          ),
-          -- First allocate to recent POs
-          allocations_recent AS (
-            SELECT 
-              po.po_id,
-              po.pid,
-              r.receiving_id,
-              LEAST(po.remaining_qty, r.remaining_qty) as allocated_qty,
-              r.cost_each,
-              COALESCE(r.received_date, NOW()) as received_date,
-              r.received_by,
-              po.age_group,
-              po.rank_in_group,
-              r.rank,
-              'recent' as allocation_type
-            FROM ranked_pos po
-            JOIN ranked_receivings r ON po.pid = r.pid
-            WHERE po.age_group = 1
-            ORDER BY po.pid, po.rank_in_group, r.rank
-          ),
-          -- Then allocate to older POs
-          remaining_after_recent AS (
-            SELECT 
-              r.receiving_id,
-              r.pid,
-              r.remaining_qty - COALESCE(SUM(a.allocated_qty), 0) as remaining_qty,
-              r.received_date,
-              r.cost_each,
-              r.received_by,
-              r.rank
-            FROM ranked_receivings r
-            LEFT JOIN allocations_recent a ON r.receiving_id = a.receiving_id AND r.pid = a.pid
-            GROUP BY r.receiving_id, r.pid, r.remaining_qty, r.received_date, r.cost_each, r.received_by, r.rank
-            HAVING r.remaining_qty > COALESCE(SUM(a.allocated_qty), 0)
-          ),
-          allocations_old AS (
-            SELECT 
-              po.po_id,
-              po.pid,
-              r.receiving_id,
-              LEAST(po.remaining_qty, r.remaining_qty) as allocated_qty,
-              r.cost_each,
-              COALESCE(r.received_date, NOW()) as received_date,
-              r.received_by,
-              po.age_group,
-              po.rank_in_group,
-              r.rank,
-              'old' as allocation_type
-            FROM ranked_pos po
-            JOIN remaining_after_recent r ON po.pid = r.pid
-            WHERE po.age_group = 2
-            ORDER BY po.pid, po.rank_in_group, r.rank
-          ),
-          -- Combine allocations
-          combined_allocations AS (
-            SELECT * FROM allocations_recent
-            UNION ALL
-            SELECT * FROM allocations_old
-          )
-          -- Insert into allocations table
-          INSERT INTO temp_receiving_allocations (
-            po_id, pid, receiving_id, allocated_qty, cost_each, received_date, received_by
-          )
-          SELECT 
-            po_id, pid, receiving_id, allocated_qty, cost_each, 
-            COALESCE(received_date, NOW()) as received_date, 
-            received_by
-          FROM combined_allocations
-          WHERE allocated_qty > 0
-        `
-      }
-    ];
-
-    // Execute FIFO steps with progress tracking
-    for (let i = 0; i < fifoSteps.length; i++) {
-      const step = fifoSteps[i];
-      outputProgress({
-        status: "running",
-        operation: "Purchase orders import",
-        message: `FIFO allocation step ${i+1}/${fifoSteps.length}: ${step.name}`,
-        current: i,
-        total: fifoSteps.length
-      });
-      
-      await localConnection.query(step.query);
-    }
-
-    // 4. Generate final purchase order records with receiving data
-    outputProgress({
-      status: "running",
-      operation: "Purchase orders import",
-      message: "Generating final purchase order records"
-    });
-
-    const [finalResult] = await localConnection.query(`
-      WITH 
-      receiving_summaries AS (
-        SELECT 
-          po_id,
-          pid,
-          SUM(allocated_qty) as total_received,
-          JSONB_AGG(
-            JSONB_BUILD_OBJECT(
-              'receiving_id', receiving_id,
-              'qty', allocated_qty,
-              'date', COALESCE(received_date, NOW()),
-              'cost', cost_each,
-              'received_by', received_by,
-              'received_by_name', CASE 
-                WHEN received_by IS NOT NULL AND received_by > 0 THEN
-                  (SELECT CONCAT(firstname, ' ', lastname) 
-                   FROM employee_names 
-                   WHERE employeeid = received_by)
-                ELSE NULL
-              END
-            ) ORDER BY COALESCE(received_date, NOW())
-          ) as receiving_history,
-          MIN(COALESCE(received_date, NOW())) as first_received_date,
-          MAX(COALESCE(received_date, NOW())) as last_received_date,
-          STRING_AGG(
-            DISTINCT CASE WHEN received_by IS NOT NULL AND received_by > 0 
-              THEN CAST(received_by AS TEXT) 
-              ELSE NULL 
-            END,
-            ','
-          ) as received_by_list,
-          STRING_AGG(
-            DISTINCT CASE 
-              WHEN ra.received_by IS NOT NULL AND ra.received_by > 0 THEN
-                (SELECT CONCAT(firstname, ' ', lastname) 
-                 FROM employee_names 
-                 WHERE employeeid = ra.received_by)
-              ELSE NULL 
-            END,
-            ', '
-          ) as received_by_names
-        FROM temp_receiving_allocations ra
-        GROUP BY po_id, pid
-      ),
-      cost_averaging AS (
-        SELECT 
-          ra.po_id,
-          ra.pid,
-          SUM(ra.allocated_qty * ra.cost_each) / NULLIF(SUM(ra.allocated_qty), 0) as avg_cost
-        FROM temp_receiving_allocations ra
-        GROUP BY ra.po_id, ra.pid
-      )
-      INSERT INTO purchase_orders (
-        po_id, vendor, date, expected_date, pid, sku, name,
-        cost_price, po_cost_price, status, receiving_status, notes, long_note,
-        ordered, received, received_date, last_received_date, received_by,
-        receiving_history
-      )
-      SELECT 
-        po.po_id,
-        po.vendor,
-        CASE
-          WHEN po.date IS NOT NULL THEN po.date
-          -- For standalone receivings, try to use the receiving date from history
-          WHEN po.po_id LIKE 'R%' AND rs.first_received_date IS NOT NULL THEN rs.first_received_date
-          -- As a last resort for data integrity, use Unix epoch (Jan 1, 1970)
-          ELSE to_timestamp(0)
-        END as date,
-        NULLIF(po.expected_date::text, '0000-00-00')::date as expected_date,
-        po.pid,
-        po.sku,
-        po.name,
-        COALESCE(ca.avg_cost, po.po_cost_price) as cost_price,
-        po.po_cost_price,
-        CASE WHEN po.status IS NULL THEN 1 ELSE po.status END as status,
-        CASE 
-          WHEN rs.total_received IS NULL THEN 1
-          WHEN rs.total_received = 0 THEN 1
-          WHEN rs.total_received < po.ordered THEN 30
-          WHEN rs.total_received >= po.ordered THEN 40
-          ELSE 1
-        END as receiving_status,
-        po.notes,
-        po.long_note,
-        COALESCE(po.ordered, 0),
-        COALESCE(rs.total_received, 0),
-        NULLIF(rs.first_received_date::text, '0000-00-00 00:00:00')::timestamp with time zone as received_date,
-        NULLIF(rs.last_received_date::text, '0000-00-00 00:00:00')::timestamp with time zone as last_received_date,
-        CASE 
-          WHEN rs.received_by_list IS NULL THEN NULL
-          ELSE rs.received_by_names
-        END as received_by,
-        rs.receiving_history
-      FROM temp_purchase_orders po
-      LEFT JOIN receiving_summaries rs ON po.po_id = rs.po_id AND po.pid = rs.pid
-      LEFT JOIN cost_averaging ca ON po.po_id = ca.po_id AND po.pid = ca.pid
-        ON CONFLICT (po_id, pid) DO UPDATE SET
-          vendor = EXCLUDED.vendor,
-          date = EXCLUDED.date,
-          expected_date = EXCLUDED.expected_date,
-        sku = EXCLUDED.sku,
-        name = EXCLUDED.name,
-        cost_price = EXCLUDED.cost_price,
-        po_cost_price = EXCLUDED.po_cost_price,
-          status = EXCLUDED.status,
-        receiving_status = EXCLUDED.receiving_status,
-          notes = EXCLUDED.notes,
-        long_note = EXCLUDED.long_note,
-          ordered = EXCLUDED.ordered,
-        received = EXCLUDED.received,
-        received_date = EXCLUDED.received_date,
-        last_received_date = EXCLUDED.last_received_date,
-        received_by = EXCLUDED.received_by,
-        receiving_history = EXCLUDED.receiving_history,
-        updated = CURRENT_TIMESTAMP
-      RETURNING (xmax = 0) as inserted
-    `);
-
-    recordsAdded = finalResult.rows.filter(r => r.inserted).length;
-    recordsUpdated = finalResult.rows.filter(r => !r.inserted).length;
-
-    // Update sync status
-    await localConnection.query(`
-      INSERT INTO sync_status (table_name, last_sync_timestamp)
-      VALUES ('purchase_orders', NOW())
-      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_receivings;
-      DROP TABLE IF EXISTS temp_receiving_allocations;
-      DROP TABLE IF EXISTS employee_names;
-    `);
-    
-    // Commit transaction
-    await localConnection.commit();
-
-    return {
-      status: "complete",
-      recordsAdded: recordsAdded || 0,
-      recordsUpdated: recordsUpdated || 0,
-      totalRecords: totalProcessed
-    };
-  } catch (error) {
-    console.error("Error during purchase orders import:", error);
-    
-    // Rollback transaction
-    try {
-      await localConnection.rollback();
-    } catch (rollbackError) {
-      console.error('Error during rollback:', rollbackError.message);
-    }
-    
-    return {
-      status: "error",
-      error: error.message,
-      recordsAdded: 0,
-      recordsUpdated: 0,
-      totalRecords: 0
-    };
-  }
-}
-
-module.exports = importPurchaseOrders;

inventory-server/scripts/import/utils.js

@@ -1,156 +0,0 @@
-const mysql = require("mysql2/promise");
-const { Client } = require("ssh2");
-const { Pool } = require('pg');
-const dotenv = require("dotenv");
-const path = require("path");
-
-// Helper function to setup SSH tunnel
-async function setupSshTunnel(sshConfig) {
-  return new Promise((resolve, reject) => {
-    const ssh = new Client();
-
-    ssh.on('error', (err) => {
-      console.error('SSH connection error:', err);
-    });
-
-    ssh.on('end', () => {
-      console.log('SSH connection ended normally');
-    });
-
-    ssh.on('close', () => {
-      console.log('SSH connection closed');
-    });
-
-    ssh
-      .on("ready", () => {
-        ssh.forwardOut(
-          "127.0.0.1",
-          0,
-          sshConfig.prodDbConfig.host,
-          sshConfig.prodDbConfig.port,
-          async (err, stream) => {
-            if (err) reject(err);
-            resolve({ ssh, stream });
-          }
-        );
-      })
-      .connect(sshConfig.ssh);
-  });
-}
-
-// Helper function to setup database connections
-async function setupConnections(sshConfig) {
-  const tunnel = await setupSshTunnel(sshConfig);
-  
-  // Setup MySQL connection for production
-  const prodConnection = await mysql.createConnection({
-    ...sshConfig.prodDbConfig,
-    stream: tunnel.stream,
-  });
-
-  // Setup PostgreSQL connection pool for local
-  const localPool = new Pool(sshConfig.localDbConfig);
-
-  // 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
-async function closeConnections(connections) {
-  const { ssh, prodConnection, localConnection } = connections;
-  
-  try {
-    if (prodConnection) await prodConnection.end();
-    if (localConnection) await localConnection.end();
-    
-    // Wait a bit for any pending data to be written before closing SSH
-    await new Promise(resolve => setTimeout(resolve, 100));
-    
-    if (ssh) {
-      ssh.on('close', () => {
-        console.log('SSH connection closed cleanly');
-      });
-      ssh.end();
-    }
-  } catch (err) {
-    console.error('Error during cleanup:', err);
-  }
-}
-
-module.exports = {
-  setupConnections,
-  closeConnections
-}; 

inventory-server/scripts/metrics-new/calculate_brand_metrics.sql

@@ -0,0 +1,135 @@
+-- Description: Calculates and updates aggregated metrics per brand.
+-- Dependencies: product_metrics, products, calculate_status table.
+-- Frequency: Daily (after product_metrics update).
+
+DO $$
+DECLARE
+    _module_name VARCHAR := 'brand_metrics';
+    _start_time TIMESTAMPTZ := clock_timestamp();
+    _min_revenue NUMERIC := 50.00; -- Minimum revenue threshold for margin calculation
+BEGIN
+    RAISE NOTICE 'Running % calculation...', _module_name;
+
+    WITH BrandAggregates AS (
+        -- Aggregate metrics from product_metrics table per brand
+        SELECT
+            COALESCE(p.brand, 'Unbranded') AS brand_group, -- Group NULL/empty brands together
+            COUNT(DISTINCT pm.pid) AS product_count,
+            COUNT(DISTINCT CASE WHEN pm.is_visible THEN pm.pid END) AS active_product_count,
+            COUNT(DISTINCT CASE WHEN pm.is_replenishable THEN pm.pid END) AS replenishable_product_count,
+            SUM(pm.current_stock) AS current_stock_units,
+            SUM(pm.current_stock_cost) AS current_stock_cost,
+            SUM(pm.current_stock_retail) AS current_stock_retail,
+            -- Only include products with valid sales data in each time period
+            COUNT(DISTINCT CASE WHEN pm.sales_7d > 0 THEN pm.pid END) AS products_with_sales_7d,
+            SUM(CASE WHEN pm.sales_7d > 0 THEN pm.sales_7d ELSE 0 END) AS sales_7d,
+            SUM(CASE WHEN pm.revenue_7d > 0 THEN pm.revenue_7d ELSE 0 END) AS revenue_7d,
+            
+            COUNT(DISTINCT CASE WHEN pm.sales_30d > 0 THEN pm.pid END) AS products_with_sales_30d,
+            SUM(CASE WHEN pm.sales_30d > 0 THEN pm.sales_30d ELSE 0 END) AS sales_30d,
+            SUM(CASE WHEN pm.revenue_30d > 0 THEN pm.revenue_30d ELSE 0 END) AS revenue_30d,
+            SUM(CASE WHEN pm.cogs_30d > 0 THEN pm.cogs_30d ELSE 0 END) AS cogs_30d,
+            SUM(CASE WHEN pm.profit_30d != 0 THEN pm.profit_30d ELSE 0 END) AS profit_30d,
+            
+            COUNT(DISTINCT CASE WHEN pm.sales_365d > 0 THEN pm.pid END) AS products_with_sales_365d,
+            SUM(CASE WHEN pm.sales_365d > 0 THEN pm.sales_365d ELSE 0 END) AS sales_365d,
+            SUM(CASE WHEN pm.revenue_365d > 0 THEN pm.revenue_365d ELSE 0 END) AS revenue_365d,
+            
+            COUNT(DISTINCT CASE WHEN pm.lifetime_sales > 0 THEN pm.pid END) AS products_with_lifetime_sales,
+            SUM(CASE WHEN pm.lifetime_sales > 0 THEN pm.lifetime_sales ELSE 0 END) AS lifetime_sales,
+            SUM(CASE WHEN pm.lifetime_revenue > 0 THEN pm.lifetime_revenue ELSE 0 END) AS lifetime_revenue
+        FROM public.product_metrics pm
+        JOIN public.products p ON pm.pid = p.pid
+        GROUP BY brand_group
+    ),
+    AllBrands AS (
+         -- Ensure all brands from products table are included, mapping NULL/empty to 'Unbranded'
+        SELECT DISTINCT COALESCE(brand, 'Unbranded') as brand_group
+        FROM public.products
+    )
+    INSERT INTO public.brand_metrics (
+        brand_name, last_calculated,
+        product_count, active_product_count, replenishable_product_count,
+        current_stock_units, current_stock_cost, current_stock_retail,
+        sales_7d, revenue_7d, sales_30d, revenue_30d, profit_30d, cogs_30d,
+        sales_365d, revenue_365d, lifetime_sales, lifetime_revenue,
+        avg_margin_30d
+    )
+    SELECT
+        b.brand_group,
+        _start_time,
+        -- Base Aggregates
+        COALESCE(ba.product_count, 0),
+        COALESCE(ba.active_product_count, 0),
+        COALESCE(ba.replenishable_product_count, 0),
+        COALESCE(ba.current_stock_units, 0),
+        COALESCE(ba.current_stock_cost, 0.00),
+        COALESCE(ba.current_stock_retail, 0.00),
+        -- Sales Aggregates
+        COALESCE(ba.sales_7d, 0), COALESCE(ba.revenue_7d, 0.00),
+        COALESCE(ba.sales_30d, 0), COALESCE(ba.revenue_30d, 0.00),
+        COALESCE(ba.profit_30d, 0.00), COALESCE(ba.cogs_30d, 0.00),
+        COALESCE(ba.sales_365d, 0), COALESCE(ba.revenue_365d, 0.00),
+        COALESCE(ba.lifetime_sales, 0), COALESCE(ba.lifetime_revenue, 0.00),
+        -- KPIs - Calculate margin only for brands with significant revenue
+        CASE
+            WHEN COALESCE(ba.revenue_30d, 0) >= _min_revenue THEN
+                -- Directly calculate margin from revenue and cogs for consistency
+                -- This is mathematically equivalent to profit/revenue but more explicit
+                ((COALESCE(ba.revenue_30d, 0) - COALESCE(ba.cogs_30d, 0)) / COALESCE(ba.revenue_30d, 1)) * 100.0
+            ELSE NULL -- No margin for low/no revenue brands
+        END
+    FROM AllBrands b
+    LEFT JOIN BrandAggregates ba ON b.brand_group = ba.brand_group
+
+    ON CONFLICT (brand_name) DO UPDATE SET
+        last_calculated = EXCLUDED.last_calculated,
+        product_count = EXCLUDED.product_count,
+        active_product_count = EXCLUDED.active_product_count,
+        replenishable_product_count = EXCLUDED.replenishable_product_count,
+        current_stock_units = EXCLUDED.current_stock_units,
+        current_stock_cost = EXCLUDED.current_stock_cost,
+        current_stock_retail = EXCLUDED.current_stock_retail,
+        sales_7d = EXCLUDED.sales_7d, revenue_7d = EXCLUDED.revenue_7d,
+        sales_30d = EXCLUDED.sales_30d, revenue_30d = EXCLUDED.revenue_30d,
+        profit_30d = EXCLUDED.profit_30d, cogs_30d = EXCLUDED.cogs_30d,
+        sales_365d = EXCLUDED.sales_365d, revenue_365d = EXCLUDED.revenue_365d,
+        lifetime_sales = EXCLUDED.lifetime_sales, lifetime_revenue = EXCLUDED.lifetime_revenue,
+        avg_margin_30d = EXCLUDED.avg_margin_30d
+    WHERE -- Only update if at least one value has changed
+        brand_metrics.product_count IS DISTINCT FROM EXCLUDED.product_count OR
+        brand_metrics.active_product_count IS DISTINCT FROM EXCLUDED.active_product_count OR
+        brand_metrics.current_stock_units IS DISTINCT FROM EXCLUDED.current_stock_units OR
+        brand_metrics.sales_30d IS DISTINCT FROM EXCLUDED.sales_30d OR
+        brand_metrics.revenue_30d IS DISTINCT FROM EXCLUDED.revenue_30d OR
+        brand_metrics.lifetime_sales IS DISTINCT FROM EXCLUDED.lifetime_sales;
+
+    -- Update calculate_status
+    INSERT INTO public.calculate_status (module_name, last_calculation_timestamp)
+    VALUES (_module_name, _start_time)
+    ON CONFLICT (module_name) DO UPDATE SET last_calculation_timestamp = _start_time;
+
+    RAISE NOTICE 'Finished % calculation. Duration: %', _module_name, clock_timestamp() - _start_time;
+END $$;
+
+-- Return metrics about the update operation for tracking
+WITH update_stats AS (
+    SELECT 
+        COUNT(*) as total_brands,
+        COUNT(*) FILTER (WHERE last_calculated >= NOW() - INTERVAL '5 minutes') as rows_processed,
+        SUM(product_count) as total_products,
+        SUM(active_product_count) as total_active_products,
+        SUM(sales_30d) as total_sales_30d,
+        SUM(revenue_30d) as total_revenue_30d,
+        AVG(avg_margin_30d) as overall_avg_margin_30d
+    FROM public.brand_metrics
+)
+SELECT 
+    rows_processed,
+    total_brands,
+    total_products::int,
+    total_active_products::int,
+    total_sales_30d::int,
+    ROUND(total_revenue_30d, 2) as total_revenue_30d,
+    ROUND(overall_avg_margin_30d, 2) as overall_avg_margin_30d
+FROM update_stats;

inventory-server/scripts/metrics-new/calculate_category_metrics.sql

@@ -0,0 +1,309 @@
+-- Description: Calculates and updates aggregated metrics per category.
+-- Dependencies: product_metrics, products, categories, product_categories, calculate_status table.
+-- Frequency: Daily (after product_metrics update).
+
+DO $$
+DECLARE
+    _module_name VARCHAR := 'category_metrics';
+    _start_time TIMESTAMPTZ := clock_timestamp();
+    _min_revenue NUMERIC := 50.00; -- Minimum revenue threshold for margin calculation
+BEGIN
+    RAISE NOTICE 'Running % calculation...', _module_name;
+
+    WITH 
+    -- Identify the hierarchy depth for each category
+    CategoryDepth AS (
+        WITH RECURSIVE CategoryTree AS (
+            -- Base case: Start with categories without parents (root categories)
+            SELECT cat_id, name, parent_id, 0 AS depth
+            FROM public.categories
+            WHERE parent_id IS NULL
+            
+            UNION ALL
+            
+            -- Recursive step: Add child categories with incremented depth
+            SELECT c.cat_id, c.name, c.parent_id, ct.depth + 1
+            FROM public.categories c
+            JOIN CategoryTree ct ON c.parent_id = ct.cat_id
+        )
+        SELECT cat_id, depth
+        FROM CategoryTree
+    ),
+    -- For each product, find the most specific (deepest) category it belongs to
+    ProductDeepestCategory AS (
+        SELECT 
+            pc.pid,
+            pc.cat_id
+        FROM public.product_categories pc
+        JOIN CategoryDepth cd ON pc.cat_id = cd.cat_id
+        -- This is the key part: for each product, select only the category with maximum depth
+        WHERE (pc.pid, cd.depth) IN (
+            SELECT pc2.pid, MAX(cd2.depth)
+            FROM public.product_categories pc2
+            JOIN CategoryDepth cd2 ON pc2.cat_id = cd2.cat_id
+            GROUP BY pc2.pid
+        )
+    ),
+    -- Calculate metrics only at the most specific category level for each product
+    -- These are the direct metrics (only products directly in this category)
+    DirectCategoryMetrics AS (
+        SELECT
+            pdc.cat_id,
+            -- Counts
+            COUNT(DISTINCT pm.pid) AS product_count,
+            COUNT(DISTINCT CASE WHEN pm.is_visible THEN pm.pid END) AS active_product_count,
+            COUNT(DISTINCT CASE WHEN pm.is_replenishable THEN pm.pid END) AS replenishable_product_count,
+            -- Current Stock
+            SUM(pm.current_stock) AS current_stock_units,
+            SUM(pm.current_stock_cost) AS current_stock_cost,
+            SUM(pm.current_stock_retail) AS current_stock_retail,
+            -- Rolling Periods - Only include products with actual sales in each period
+            SUM(CASE WHEN pm.sales_7d > 0 THEN pm.sales_7d ELSE 0 END) AS sales_7d,
+            SUM(CASE WHEN pm.revenue_7d > 0 THEN pm.revenue_7d ELSE 0 END) AS revenue_7d,
+            SUM(CASE WHEN pm.sales_30d > 0 THEN pm.sales_30d ELSE 0 END) AS sales_30d,
+            SUM(CASE WHEN pm.revenue_30d > 0 THEN pm.revenue_30d ELSE 0 END) AS revenue_30d,
+            SUM(CASE WHEN pm.cogs_30d > 0 THEN pm.cogs_30d ELSE 0 END) AS cogs_30d,
+            SUM(CASE WHEN pm.profit_30d != 0 THEN pm.profit_30d ELSE 0 END) AS profit_30d,
+            SUM(CASE WHEN pm.sales_365d > 0 THEN pm.sales_365d ELSE 0 END) AS sales_365d,
+            SUM(CASE WHEN pm.revenue_365d > 0 THEN pm.revenue_365d ELSE 0 END) AS revenue_365d,
+            SUM(CASE WHEN pm.lifetime_sales > 0 THEN pm.lifetime_sales ELSE 0 END) AS lifetime_sales,
+            SUM(CASE WHEN pm.lifetime_revenue > 0 THEN pm.lifetime_revenue ELSE 0 END) AS lifetime_revenue,
+            -- Data for KPIs - Only average stock for products with stock
+            SUM(CASE WHEN pm.avg_stock_units_30d > 0 THEN pm.avg_stock_units_30d ELSE 0 END) AS total_avg_stock_units_30d
+        FROM public.product_metrics pm
+        JOIN ProductDeepestCategory pdc ON pm.pid = pdc.pid
+        GROUP BY pdc.cat_id
+    ),
+    -- Build a category lookup table for parent relationships
+    CategoryHierarchyPaths AS (
+        WITH RECURSIVE ParentPaths AS (
+            -- Base case: All categories with their immediate parents
+            SELECT 
+                cat_id,
+                cat_id as leaf_id, -- Every category is its own leaf initially
+                ARRAY[cat_id] as path
+            FROM public.categories
+            
+            UNION ALL
+            
+            -- Recursive step: Walk up the parent chain
+            SELECT
+                c.parent_id as cat_id,
+                pp.leaf_id, -- Keep the original leaf_id
+                c.parent_id || pp.path as path
+            FROM ParentPaths pp
+            JOIN public.categories c ON pp.cat_id = c.cat_id
+            WHERE c.parent_id IS NOT NULL -- Stop at root categories
+        )
+        -- Select distinct paths to avoid duplication
+        SELECT DISTINCT cat_id, leaf_id
+        FROM ParentPaths
+    ),
+    -- Aggregate metrics from leaf categories to their ancestors without duplication
+    -- These are the rolled-up metrics (including all child categories)
+    RollupMetrics AS (
+        SELECT
+            chp.cat_id,
+            -- For each parent category, count distinct products to avoid duplication
+            COUNT(DISTINCT dcm.cat_id) AS child_categories_count,
+            SUM(dcm.product_count) AS rollup_product_count,
+            SUM(dcm.active_product_count) AS rollup_active_product_count,
+            SUM(dcm.replenishable_product_count) AS rollup_replenishable_product_count,
+            SUM(dcm.current_stock_units) AS rollup_current_stock_units,
+            SUM(dcm.current_stock_cost) AS rollup_current_stock_cost,
+            SUM(dcm.current_stock_retail) AS rollup_current_stock_retail,
+            SUM(dcm.sales_7d) AS rollup_sales_7d,
+            SUM(dcm.revenue_7d) AS rollup_revenue_7d,
+            SUM(dcm.sales_30d) AS rollup_sales_30d,
+            SUM(dcm.revenue_30d) AS rollup_revenue_30d,
+            SUM(dcm.cogs_30d) AS rollup_cogs_30d,
+            SUM(dcm.profit_30d) AS rollup_profit_30d,
+            SUM(dcm.sales_365d) AS rollup_sales_365d,
+            SUM(dcm.revenue_365d) AS rollup_revenue_365d,
+            SUM(dcm.lifetime_sales) AS rollup_lifetime_sales,
+            SUM(dcm.lifetime_revenue) AS rollup_lifetime_revenue,
+            SUM(dcm.total_avg_stock_units_30d) AS rollup_total_avg_stock_units_30d
+        FROM CategoryHierarchyPaths chp
+        JOIN DirectCategoryMetrics dcm ON chp.leaf_id = dcm.cat_id
+        GROUP BY chp.cat_id
+    ),
+    -- Combine direct and rollup metrics
+    CombinedMetrics AS (
+        SELECT
+            c.cat_id,
+            c.name,
+            c.type,
+            c.parent_id,
+            -- Direct metrics (just this category)
+            COALESCE(dcm.product_count, 0) AS direct_product_count,
+            COALESCE(dcm.active_product_count, 0) AS direct_active_product_count,
+            COALESCE(dcm.replenishable_product_count, 0) AS direct_replenishable_product_count,
+            COALESCE(dcm.current_stock_units, 0) AS direct_current_stock_units,
+            COALESCE(dcm.current_stock_cost, 0) AS direct_current_stock_cost,
+            COALESCE(dcm.current_stock_retail, 0) AS direct_current_stock_retail,
+            COALESCE(dcm.sales_7d, 0) AS direct_sales_7d,
+            COALESCE(dcm.revenue_7d, 0) AS direct_revenue_7d,
+            COALESCE(dcm.sales_30d, 0) AS direct_sales_30d,
+            COALESCE(dcm.revenue_30d, 0) AS direct_revenue_30d,
+            COALESCE(dcm.cogs_30d, 0) AS direct_cogs_30d,
+            COALESCE(dcm.profit_30d, 0) AS direct_profit_30d,
+            COALESCE(dcm.sales_365d, 0) AS direct_sales_365d,
+            COALESCE(dcm.revenue_365d, 0) AS direct_revenue_365d,
+            COALESCE(dcm.lifetime_sales, 0) AS direct_lifetime_sales,
+            COALESCE(dcm.lifetime_revenue, 0) AS direct_lifetime_revenue,
+            COALESCE(dcm.total_avg_stock_units_30d, 0) AS direct_avg_stock_units_30d,
+            
+            -- Rolled up metrics (this category + all children)
+            COALESCE(rm.rollup_product_count, 0) AS product_count,
+            COALESCE(rm.rollup_active_product_count, 0) AS active_product_count,
+            COALESCE(rm.rollup_replenishable_product_count, 0) AS replenishable_product_count,
+            COALESCE(rm.rollup_current_stock_units, 0) AS current_stock_units,
+            COALESCE(rm.rollup_current_stock_cost, 0) AS current_stock_cost,
+            COALESCE(rm.rollup_current_stock_retail, 0) AS current_stock_retail,
+            COALESCE(rm.rollup_sales_7d, 0) AS sales_7d,
+            COALESCE(rm.rollup_revenue_7d, 0) AS revenue_7d,
+            COALESCE(rm.rollup_sales_30d, 0) AS sales_30d,
+            COALESCE(rm.rollup_revenue_30d, 0) AS revenue_30d,
+            COALESCE(rm.rollup_cogs_30d, 0) AS cogs_30d,
+            COALESCE(rm.rollup_profit_30d, 0) AS profit_30d,
+            COALESCE(rm.rollup_sales_365d, 0) AS sales_365d,
+            COALESCE(rm.rollup_revenue_365d, 0) AS revenue_365d,
+            COALESCE(rm.rollup_lifetime_sales, 0) AS lifetime_sales,
+            COALESCE(rm.rollup_lifetime_revenue, 0) AS lifetime_revenue,
+            COALESCE(rm.rollup_total_avg_stock_units_30d, 0) AS total_avg_stock_units_30d
+        FROM public.categories c
+        LEFT JOIN DirectCategoryMetrics dcm ON c.cat_id = dcm.cat_id
+        LEFT JOIN RollupMetrics rm ON c.cat_id = rm.cat_id
+    )
+    INSERT INTO public.category_metrics (
+        category_id, category_name, category_type, parent_id, last_calculated,
+        -- Store all direct and rolled up metrics
+        product_count, active_product_count, replenishable_product_count,
+        current_stock_units, current_stock_cost, current_stock_retail,
+        sales_7d, revenue_7d, sales_30d, revenue_30d, profit_30d, cogs_30d,
+        sales_365d, revenue_365d, lifetime_sales, lifetime_revenue,
+        -- Also store direct metrics with direct_ prefix
+        direct_product_count, direct_active_product_count, direct_replenishable_product_count,
+        direct_current_stock_units, direct_stock_cost, direct_stock_retail,
+        direct_sales_7d, direct_revenue_7d, direct_sales_30d, direct_revenue_30d, 
+        direct_profit_30d, direct_cogs_30d, direct_sales_365d, direct_revenue_365d,
+        direct_lifetime_sales, direct_lifetime_revenue,
+        -- KPIs
+        avg_margin_30d, stock_turn_30d
+    )
+    SELECT
+        cm.cat_id,
+        cm.name,
+        cm.type,
+        cm.parent_id,
+        _start_time,
+        -- Rolled-up metrics (total including children)
+        cm.product_count,
+        cm.active_product_count,
+        cm.replenishable_product_count,
+        cm.current_stock_units,
+        cm.current_stock_cost,
+        cm.current_stock_retail,
+        cm.sales_7d, cm.revenue_7d,
+        cm.sales_30d, cm.revenue_30d, cm.profit_30d, cm.cogs_30d,
+        cm.sales_365d, cm.revenue_365d,
+        cm.lifetime_sales, cm.lifetime_revenue,
+        -- Direct metrics (just this category)
+        cm.direct_product_count,
+        cm.direct_active_product_count,
+        cm.direct_replenishable_product_count,
+        cm.direct_current_stock_units,
+        cm.direct_current_stock_cost,
+        cm.direct_current_stock_retail,
+        cm.direct_sales_7d, cm.direct_revenue_7d,
+        cm.direct_sales_30d, cm.direct_revenue_30d, cm.direct_profit_30d, cm.direct_cogs_30d,
+        cm.direct_sales_365d, cm.direct_revenue_365d,
+        cm.direct_lifetime_sales, cm.direct_lifetime_revenue,
+        -- KPIs - Calculate margin only for categories with significant revenue
+        CASE
+            WHEN cm.revenue_30d >= _min_revenue THEN
+                ((cm.revenue_30d - cm.cogs_30d) / cm.revenue_30d) * 100.0
+            ELSE NULL -- No margin for low/no revenue categories
+        END,
+        -- Stock Turn calculation
+        CASE
+            WHEN cm.total_avg_stock_units_30d > 0 THEN
+                cm.sales_30d / cm.total_avg_stock_units_30d
+            ELSE NULL -- No stock turn if no average stock
+        END
+    FROM CombinedMetrics cm
+
+    ON CONFLICT (category_id) DO UPDATE SET
+        category_name = EXCLUDED.category_name,
+        category_type = EXCLUDED.category_type,
+        parent_id = EXCLUDED.parent_id,
+        last_calculated = EXCLUDED.last_calculated,
+        
+        -- ROLLED-UP METRICS (includes this category + all descendants)
+        product_count = EXCLUDED.product_count,
+        active_product_count = EXCLUDED.active_product_count,
+        replenishable_product_count = EXCLUDED.replenishable_product_count,
+        current_stock_units = EXCLUDED.current_stock_units,
+        current_stock_cost = EXCLUDED.current_stock_cost,
+        current_stock_retail = EXCLUDED.current_stock_retail,
+        sales_7d = EXCLUDED.sales_7d, revenue_7d = EXCLUDED.revenue_7d,
+        sales_30d = EXCLUDED.sales_30d, revenue_30d = EXCLUDED.revenue_30d,
+        profit_30d = EXCLUDED.profit_30d, cogs_30d = EXCLUDED.cogs_30d,
+        sales_365d = EXCLUDED.sales_365d, revenue_365d = EXCLUDED.revenue_365d,
+        lifetime_sales = EXCLUDED.lifetime_sales, lifetime_revenue = EXCLUDED.lifetime_revenue,
+        
+        -- DIRECT METRICS (only products directly in this category)
+        direct_product_count = EXCLUDED.direct_product_count,
+        direct_active_product_count = EXCLUDED.direct_active_product_count,
+        direct_replenishable_product_count = EXCLUDED.direct_replenishable_product_count,
+        direct_current_stock_units = EXCLUDED.direct_current_stock_units,
+        direct_stock_cost = EXCLUDED.direct_stock_cost,
+        direct_stock_retail = EXCLUDED.direct_stock_retail,
+        direct_sales_7d = EXCLUDED.direct_sales_7d, direct_revenue_7d = EXCLUDED.direct_revenue_7d,
+        direct_sales_30d = EXCLUDED.direct_sales_30d, direct_revenue_30d = EXCLUDED.direct_revenue_30d,
+        direct_profit_30d = EXCLUDED.direct_profit_30d, direct_cogs_30d = EXCLUDED.direct_cogs_30d,
+        direct_sales_365d = EXCLUDED.direct_sales_365d, direct_revenue_365d = EXCLUDED.direct_revenue_365d,
+        direct_lifetime_sales = EXCLUDED.direct_lifetime_sales, direct_lifetime_revenue = EXCLUDED.direct_lifetime_revenue,
+        
+        -- Calculated KPIs
+        avg_margin_30d = EXCLUDED.avg_margin_30d,
+        stock_turn_30d = EXCLUDED.stock_turn_30d
+    WHERE -- Only update if at least one value has changed
+        category_metrics.product_count IS DISTINCT FROM EXCLUDED.product_count OR
+        category_metrics.active_product_count IS DISTINCT FROM EXCLUDED.active_product_count OR
+        category_metrics.current_stock_units IS DISTINCT FROM EXCLUDED.current_stock_units OR
+        category_metrics.sales_30d IS DISTINCT FROM EXCLUDED.sales_30d OR
+        category_metrics.revenue_30d IS DISTINCT FROM EXCLUDED.revenue_30d OR
+        category_metrics.lifetime_sales IS DISTINCT FROM EXCLUDED.lifetime_sales OR
+        category_metrics.direct_product_count IS DISTINCT FROM EXCLUDED.direct_product_count OR
+        category_metrics.direct_sales_30d IS DISTINCT FROM EXCLUDED.direct_sales_30d;
+
+    -- Update calculate_status
+    INSERT INTO public.calculate_status (module_name, last_calculation_timestamp)
+    VALUES (_module_name, _start_time)
+    ON CONFLICT (module_name) DO UPDATE SET last_calculation_timestamp = _start_time;
+
+    RAISE NOTICE 'Finished % calculation. Duration: %', _module_name, clock_timestamp() - _start_time;
+END $$;
+
+-- Return metrics about the update operation for tracking
+WITH update_stats AS (
+    SELECT 
+        COUNT(*) as total_categories,
+        COUNT(*) FILTER (WHERE last_calculated >= NOW() - INTERVAL '5 minutes') as rows_processed,
+        COUNT(*) FILTER (WHERE category_type = 11) as main_categories, -- 11 = category
+        COUNT(*) FILTER (WHERE category_type = 12) as subcategories,  -- 12 = subcategory
+        SUM(product_count) as total_products,
+        SUM(active_product_count) as total_active_products,
+        SUM(current_stock_units) as total_stock_units
+    FROM public.category_metrics
+)
+SELECT 
+    rows_processed,
+    total_categories,
+    main_categories,
+    subcategories,
+    total_products::int,
+    total_active_products::int,
+    total_stock_units::int
+FROM update_stats;

inventory-server/scripts/metrics/brand-metrics.js

@@ -1,321 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
-const { getConnection } = require('./utils/db');
-
-async function calculateBrandMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
-    const connection = await getConnection();
-    let success = false;
-    let processedOrders = 0;
-    
-    try {
-        if (isCancelled) {
-            outputProgress({
-                status: 'cancelled',
-                operation: 'Brand metrics calculation cancelled',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: null,
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-            return {
-                processedProducts: processedCount,
-                processedOrders: 0,
-                processedPurchaseOrders: 0,
-                success
-            };
-        }
-
-        // Get order count that will be processed
-        const orderCount = await connection.query(`
-            SELECT COUNT(*) as count 
-            FROM orders o 
-            WHERE o.canceled = false
-        `);
-        processedOrders = parseInt(orderCount.rows[0].count);
-
-        outputProgress({
-            status: 'running',
-            operation: 'Starting brand metrics calculation',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // Calculate brand metrics with optimized queries
-        await connection.query(`
-            INSERT INTO brand_metrics (
-                brand,
-                product_count,
-                active_products,
-                total_stock_units,
-                total_stock_cost,
-                total_stock_retail,
-                total_revenue,
-                avg_margin,
-                growth_rate
-            )
-            WITH filtered_products AS (
-                SELECT 
-                    p.*,
-                    CASE 
-                        WHEN p.stock_quantity <= 5000 AND p.stock_quantity >= 0 
-                        THEN p.pid 
-                    END as valid_pid,
-                    CASE 
-                        WHEN p.visible = true 
-                        AND p.stock_quantity <= 5000 
-                        AND p.stock_quantity >= 0 
-                        THEN p.pid 
-                    END as active_pid,
-                    CASE 
-                        WHEN p.stock_quantity IS NULL 
-                        OR p.stock_quantity < 0 
-                        OR p.stock_quantity > 5000 
-                        THEN 0 
-                        ELSE p.stock_quantity 
-                    END as valid_stock
-                FROM products p
-                WHERE p.brand IS NOT NULL
-            ),
-            sales_periods AS (
-                SELECT 
-                    p.brand,
-                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0))) as period_revenue,
-                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0) - p.cost_price)) as period_margin,
-                    COUNT(DISTINCT DATE(o.date)) as period_days,
-                    CASE 
-                        WHEN o.date >= CURRENT_DATE - INTERVAL '3 months' THEN 'current'
-                        WHEN o.date BETWEEN CURRENT_DATE - INTERVAL '15 months' 
-                            AND CURRENT_DATE - INTERVAL '12 months' THEN 'previous'
-                    END as period_type
-                FROM filtered_products p
-                JOIN orders o ON p.pid = o.pid 
-                WHERE o.canceled = false
-                    AND o.date >= CURRENT_DATE - INTERVAL '15 months'
-                GROUP BY p.brand, period_type
-            ),
-            brand_data AS (
-                SELECT 
-                    p.brand,
-                    COUNT(DISTINCT p.valid_pid) as product_count,
-                    COUNT(DISTINCT p.active_pid) as active_products,
-                    SUM(p.valid_stock) as total_stock_units,
-                    SUM(p.valid_stock * p.cost_price) as total_stock_cost,
-                    SUM(p.valid_stock * p.price) as total_stock_retail,
-                    COALESCE(SUM(o.quantity * (o.price - COALESCE(o.discount, 0))), 0) as total_revenue,
-                    CASE 
-                        WHEN SUM(o.quantity * o.price) > 0 
-                        THEN GREATEST(
-                            -100.0,
-                            LEAST(
-                                100.0,
-                                (
-                                    SUM(o.quantity * o.price) -  -- Use gross revenue (before discounts)
-                                    SUM(o.quantity * COALESCE(p.cost_price, 0))  -- Total costs
-                                ) * 100.0 / 
-                                NULLIF(SUM(o.quantity * o.price), 0)  -- Divide by gross revenue
-                            )
-                        )
-                        ELSE 0 
-                    END as avg_margin
-                FROM filtered_products p
-                LEFT JOIN orders o ON p.pid = o.pid AND o.canceled = false
-                GROUP BY p.brand
-            )
-            SELECT 
-                bd.brand,
-                bd.product_count,
-                bd.active_products,
-                bd.total_stock_units,
-                bd.total_stock_cost,
-                bd.total_stock_retail,
-                bd.total_revenue,
-                bd.avg_margin,
-                CASE
-                    WHEN MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END) = 0 
-                         AND MAX(CASE WHEN sp.period_type = 'current' THEN sp.period_revenue END) > 0 
-                    THEN 100.0
-                    WHEN MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END) = 0 
-                    THEN 0.0
-                    ELSE GREATEST(
-                        -100.0,
-                        LEAST(
-                            ((MAX(CASE WHEN sp.period_type = 'current' THEN sp.period_revenue END) - 
-                              MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END)) / 
-                             NULLIF(ABS(MAX(CASE WHEN sp.period_type = 'previous' THEN sp.period_revenue END)), 0)) * 100.0,
-                            999.99
-                        )
-                    )
-                END as growth_rate
-            FROM brand_data bd
-            LEFT JOIN sales_periods sp ON bd.brand = sp.brand
-            GROUP BY bd.brand, bd.product_count, bd.active_products, bd.total_stock_units, 
-                     bd.total_stock_cost, bd.total_stock_retail, bd.total_revenue, bd.avg_margin
-            ON CONFLICT (brand) DO UPDATE
-            SET
-                product_count = EXCLUDED.product_count,
-                active_products = EXCLUDED.active_products,
-                total_stock_units = EXCLUDED.total_stock_units,
-                total_stock_cost = EXCLUDED.total_stock_cost,
-                total_stock_retail = EXCLUDED.total_stock_retail,
-                total_revenue = EXCLUDED.total_revenue,
-                avg_margin = EXCLUDED.avg_margin,
-                growth_rate = EXCLUDED.growth_rate,
-                last_calculated_at = CURRENT_TIMESTAMP
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.97);
-        outputProgress({
-            status: 'running',
-            operation: 'Brand metrics calculated, starting time-based metrics',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Calculate brand time-based metrics with optimized query
-        await connection.query(`
-            INSERT INTO brand_time_metrics (
-                brand,
-                year,
-                month,
-                product_count,
-                active_products,
-                total_stock_units,
-                total_stock_cost,
-                total_stock_retail,
-                total_revenue,
-                avg_margin
-            )
-            WITH filtered_products AS (
-                SELECT 
-                    p.*,
-                    CASE WHEN p.stock_quantity <= 5000 THEN p.pid END as valid_pid,
-                    CASE WHEN p.visible = true AND p.stock_quantity <= 5000 THEN p.pid END as active_pid,
-                    CASE 
-                        WHEN p.stock_quantity IS NULL OR p.stock_quantity < 0 OR p.stock_quantity > 5000 THEN 0 
-                        ELSE p.stock_quantity 
-                    END as valid_stock
-                FROM products p
-                WHERE p.brand IS NOT NULL
-            ),
-            monthly_metrics AS (
-                SELECT 
-                    p.brand,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    COUNT(DISTINCT p.valid_pid) as product_count,
-                    COUNT(DISTINCT p.active_pid) as active_products,
-                    SUM(p.valid_stock) as total_stock_units,
-                    SUM(p.valid_stock * p.cost_price) as total_stock_cost,
-                    SUM(p.valid_stock * p.price) as total_stock_retail,
-                    SUM(o.quantity * o.price) as total_revenue,
-                    CASE 
-                        WHEN SUM(o.quantity * o.price) > 0 
-                        THEN GREATEST(
-                            -100.0,
-                            LEAST(
-                                100.0,
-                                (
-                                    SUM(o.quantity * o.price) -  -- Use gross revenue (before discounts)
-                                    SUM(o.quantity * COALESCE(p.cost_price, 0))  -- Total costs
-                                ) * 100.0 / 
-                                NULLIF(SUM(o.quantity * o.price), 0)  -- Divide by gross revenue
-                            )
-                        )
-                        ELSE 0 
-                    END as avg_margin
-                FROM filtered_products p
-                LEFT JOIN orders o ON p.pid = o.pid AND o.canceled = false
-                WHERE o.date >= CURRENT_DATE - INTERVAL '12 months'
-                GROUP BY p.brand, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone)
-            )
-            SELECT *
-            FROM monthly_metrics
-            ON CONFLICT (brand, year, month) DO UPDATE
-            SET
-                product_count = EXCLUDED.product_count,
-                active_products = EXCLUDED.active_products,
-                total_stock_units = EXCLUDED.total_stock_units,
-                total_stock_cost = EXCLUDED.total_stock_cost,
-                total_stock_retail = EXCLUDED.total_stock_retail,
-                total_revenue = EXCLUDED.total_revenue,
-                avg_margin = EXCLUDED.avg_margin
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.99);
-        outputProgress({
-            status: 'running',
-            operation: 'Brand time-based metrics calculated',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // If we get here, everything completed successfully
-        success = true;
-        
-        // Update calculate_status
-        await connection.query(`
-            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
-            VALUES ('brand_metrics', NOW())
-            ON CONFLICT (module_name) DO UPDATE
-            SET last_calculation_timestamp = NOW()
-        `);
-
-        return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-    } catch (error) {
-        success = false;
-        logError(error, 'Error calculating brand metrics');
-        throw error;
-    } finally {
-        if (connection) {
-            connection.release();
-        }
-    }
-}
-
-module.exports = calculateBrandMetrics; 

inventory-server/scripts/metrics/category-metrics.js

@@ -1,554 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
-const { getConnection } = require('./utils/db');
-
-async function calculateCategoryMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
-    const connection = await getConnection();
-    let success = false;
-    let processedOrders = 0;
-    
-    try {
-        if (isCancelled) {
-            outputProgress({
-                status: 'cancelled',
-                operation: 'Category metrics calculation cancelled',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: null,
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-            return {
-                processedProducts: processedCount,
-                processedOrders: 0,
-                processedPurchaseOrders: 0,
-                success
-            };
-        }
-
-        // Get order count that will be processed
-        const orderCount = await connection.query(`
-            SELECT COUNT(*) as count 
-            FROM orders o 
-            WHERE o.canceled = false
-        `);
-        processedOrders = parseInt(orderCount.rows[0].count);
-
-        outputProgress({
-            status: 'running',
-            operation: 'Starting category metrics calculation',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-        
-        // First, calculate base category metrics
-        await connection.query(`
-            INSERT INTO category_metrics (
-                category_id,
-                product_count,
-                active_products,
-                total_value,
-                status,
-                last_calculated_at
-            )
-            SELECT 
-                c.cat_id,
-                COUNT(DISTINCT p.pid) as product_count,
-                COUNT(DISTINCT CASE WHEN p.visible = true THEN p.pid END) as active_products,
-                COALESCE(SUM(p.stock_quantity * p.cost_price), 0) as total_value,
-                c.status,
-                NOW() as last_calculated_at
-            FROM categories c
-            LEFT JOIN product_categories pc ON c.cat_id = pc.cat_id
-            LEFT JOIN products p ON pc.pid = p.pid
-            GROUP BY c.cat_id, c.status
-            ON CONFLICT (category_id) DO UPDATE
-            SET
-                product_count = EXCLUDED.product_count,
-                active_products = EXCLUDED.active_products,
-                total_value = EXCLUDED.total_value,
-                status = EXCLUDED.status,
-                last_calculated_at = EXCLUDED.last_calculated_at
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.90);
-        outputProgress({
-            status: 'running',
-            operation: 'Base category metrics calculated, updating with margin data',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Then update with margin and turnover data
-        await connection.query(`
-            WITH category_sales AS (
-                SELECT 
-                    pc.cat_id,
-                    SUM(o.quantity * o.price) as total_sales,
-                    SUM(o.quantity * (o.price - p.cost_price)) as total_margin,
-                    SUM(o.quantity) as units_sold,
-                    AVG(GREATEST(p.stock_quantity, 0)) as avg_stock,
-                    COUNT(DISTINCT DATE(o.date)) as active_days
-                FROM product_categories pc
-                JOIN products p ON pc.pid = p.pid
-                JOIN orders o ON p.pid = o.pid
-                LEFT JOIN turnover_config tc ON 
-                    (tc.category_id = pc.cat_id AND tc.vendor = p.vendor) OR
-                    (tc.category_id = pc.cat_id AND tc.vendor IS NULL) OR
-                    (tc.category_id IS NULL AND tc.vendor = p.vendor) OR
-                    (tc.category_id IS NULL AND tc.vendor IS NULL)
-                WHERE o.canceled = false 
-                    AND o.date >= CURRENT_DATE - (COALESCE(tc.calculation_period_days, 30) || ' days')::INTERVAL
-                GROUP BY pc.cat_id
-            )
-            UPDATE category_metrics
-            SET 
-                avg_margin = COALESCE(cs.total_margin * 100.0 / NULLIF(cs.total_sales, 0), 0),
-                turnover_rate = CASE 
-                    WHEN cs.avg_stock > 0 AND cs.active_days > 0 
-                    THEN LEAST(
-                        (cs.units_sold / cs.avg_stock) * (365.0 / cs.active_days),
-                        999.99
-                    )
-                    ELSE 0 
-                END,
-                last_calculated_at = NOW()
-            FROM category_sales cs
-            WHERE category_id = cs.cat_id
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.95);
-        outputProgress({
-            status: 'running',
-            operation: 'Margin data updated, calculating growth rates',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Finally update growth rates
-        await connection.query(`
-            WITH current_period AS (
-                SELECT 
-                    pc.cat_id,
-                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0)) / 
-                        (1 + COALESCE(ss.seasonality_factor, 0))) as revenue,
-                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0) - p.cost_price)) as gross_profit,
-                    COUNT(DISTINCT DATE(o.date)) as days
-                FROM product_categories pc
-                JOIN products p ON pc.pid = p.pid
-                JOIN orders o ON p.pid = o.pid
-                LEFT JOIN sales_seasonality ss ON EXTRACT(MONTH FROM o.date) = ss.month
-                WHERE o.canceled = false 
-                    AND o.date >= CURRENT_DATE - INTERVAL '3 months'
-                GROUP BY pc.cat_id
-            ),
-            previous_period AS (
-                SELECT 
-                    pc.cat_id,
-                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0)) / 
-                        (1 + COALESCE(ss.seasonality_factor, 0))) as revenue,
-                    COUNT(DISTINCT DATE(o.date)) as days
-                FROM product_categories pc
-                JOIN products p ON pc.pid = p.pid
-                JOIN orders o ON p.pid = o.pid
-                LEFT JOIN sales_seasonality ss ON EXTRACT(MONTH FROM o.date) = ss.month
-                WHERE o.canceled = false 
-                    AND o.date BETWEEN CURRENT_DATE - INTERVAL '15 months' 
-                    AND CURRENT_DATE - INTERVAL '12 months'
-                GROUP BY pc.cat_id
-            ),
-            trend_data AS (
-                SELECT 
-                    pc.cat_id,
-                    EXTRACT(MONTH FROM o.date) as month,
-                    SUM(o.quantity * (o.price - COALESCE(o.discount, 0)) / 
-                        (1 + COALESCE(ss.seasonality_factor, 0))) as revenue,
-                    COUNT(DISTINCT DATE(o.date)) as days_in_month
-                FROM product_categories pc
-                JOIN products p ON pc.pid = p.pid
-                JOIN orders o ON p.pid = o.pid
-                LEFT JOIN sales_seasonality ss ON EXTRACT(MONTH FROM o.date) = ss.month
-                WHERE o.canceled = false 
-                    AND o.date >= CURRENT_DATE - INTERVAL '15 months'
-                GROUP BY pc.cat_id, EXTRACT(MONTH FROM o.date)
-            ),
-            trend_stats AS (
-                SELECT 
-                    cat_id,
-                    COUNT(*) as n,
-                    AVG(month) as avg_x,
-                    AVG(revenue / NULLIF(days_in_month, 0)) as avg_y,
-                    SUM(month * (revenue / NULLIF(days_in_month, 0))) as sum_xy,
-                    SUM(month * month) as sum_xx
-                FROM trend_data
-                GROUP BY cat_id
-                HAVING COUNT(*) >= 6
-            ),
-            trend_analysis AS (
-                SELECT 
-                    cat_id,
-                    ((n * sum_xy) - (avg_x * n * avg_y)) / 
-                        NULLIF((n * sum_xx) - (n * avg_x * avg_x), 0) as trend_slope,
-                    avg_y as avg_daily_revenue
-                FROM trend_stats
-            ),
-            margin_calc AS (
-                SELECT 
-                    pc.cat_id,
-                    CASE 
-                        WHEN SUM(o.quantity * o.price) > 0 THEN
-                            GREATEST(
-                                -100.0,
-                                LEAST(
-                                    100.0,
-                                    (
-                                        SUM(o.quantity * o.price) -  -- Use gross revenue (before discounts)
-                                        SUM(o.quantity * COALESCE(p.cost_price, 0))  -- Total costs
-                                    ) * 100.0 / 
-                                    NULLIF(SUM(o.quantity * o.price), 0)  -- Divide by gross revenue
-                                )
-                            )
-                        ELSE NULL
-                    END as avg_margin
-                FROM product_categories pc
-                JOIN products p ON pc.pid = p.pid
-                JOIN orders o ON p.pid = o.pid
-                WHERE o.canceled = false 
-                    AND o.date >= CURRENT_DATE - INTERVAL '3 months'
-                GROUP BY pc.cat_id
-            ),
-            combined_metrics AS (
-                SELECT 
-                    COALESCE(cp.cat_id, pp.cat_id) as category_id,
-                    CASE
-                        WHEN pp.revenue = 0 AND COALESCE(cp.revenue, 0) > 0 THEN 100.0
-                        WHEN pp.revenue = 0 OR cp.revenue IS NULL THEN 0.0
-                        WHEN ta.trend_slope IS NOT NULL THEN
-                            GREATEST(
-                                -100.0,
-                                LEAST(
-                                    (ta.trend_slope / NULLIF(ta.avg_daily_revenue, 0)) * 365 * 100,
-                                    999.99
-                                )
-                            )
-                        ELSE
-                            GREATEST(
-                                -100.0,
-                                LEAST(
-                                    ((COALESCE(cp.revenue, 0) - pp.revenue) / 
-                                        NULLIF(ABS(pp.revenue), 0)) * 100.0,
-                                    999.99
-                                )
-                            )
-                    END as growth_rate,
-                    mc.avg_margin
-                FROM current_period cp
-                FULL OUTER JOIN previous_period pp ON cp.cat_id = pp.cat_id
-                LEFT JOIN trend_analysis ta ON COALESCE(cp.cat_id, pp.cat_id) = ta.cat_id
-                LEFT JOIN margin_calc mc ON COALESCE(cp.cat_id, pp.cat_id) = mc.cat_id
-            )
-            UPDATE category_metrics cm
-            SET 
-                growth_rate = CASE
-                    WHEN pp.revenue = 0 AND COALESCE(cp.revenue, 0) > 0 THEN 100.0
-                    WHEN pp.revenue = 0 OR cp.revenue IS NULL THEN 0.0
-                    WHEN ta.trend_slope IS NOT NULL THEN
-                        GREATEST(
-                            -100.0,
-                            LEAST(
-                                (ta.trend_slope / NULLIF(ta.avg_daily_revenue, 0)) * 365 * 100,
-                                999.99
-                            )
-                        )
-                    ELSE
-                        GREATEST(
-                            -100.0,
-                            LEAST(
-                                ((COALESCE(cp.revenue, 0) - pp.revenue) / 
-                                    NULLIF(ABS(pp.revenue), 0)) * 100.0,
-                                999.99
-                            )
-                        )
-                END,
-                avg_margin = COALESCE(mc.avg_margin, cm.avg_margin),
-                last_calculated_at = NOW()
-            FROM current_period cp
-            FULL OUTER JOIN previous_period pp ON cp.cat_id = pp.cat_id
-            LEFT JOIN trend_analysis ta ON COALESCE(cp.cat_id, pp.cat_id) = ta.cat_id
-            LEFT JOIN margin_calc mc ON COALESCE(cp.cat_id, pp.cat_id) = mc.cat_id
-            WHERE cm.category_id = COALESCE(cp.cat_id, pp.cat_id)
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.97);
-        outputProgress({
-            status: 'running',
-            operation: 'Growth rates calculated, updating time-based metrics',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Calculate time-based metrics
-        await connection.query(`
-            INSERT INTO category_time_metrics (
-                category_id,
-                year,
-                month,
-                product_count,
-                active_products,
-                total_value,
-                total_revenue,
-                avg_margin,
-                turnover_rate
-            )
-            SELECT 
-                pc.cat_id,
-                EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                COUNT(DISTINCT p.pid) as product_count,
-                COUNT(DISTINCT CASE WHEN p.visible = true THEN p.pid END) as active_products,
-                SUM(p.stock_quantity * p.cost_price) as total_value,
-                SUM(o.quantity * o.price) as total_revenue,
-                CASE
-                    WHEN SUM(o.quantity * o.price) > 0 THEN
-                        LEAST(
-                            GREATEST(
-                                SUM(o.quantity * (o.price - GREATEST(p.cost_price, 0))) * 100.0 / 
-                                SUM(o.quantity * o.price),
-                                -100
-                            ),
-                            100
-                        )
-                    ELSE 0
-                END as avg_margin,
-                COALESCE(
-                    LEAST(
-                        SUM(o.quantity) / NULLIF(AVG(GREATEST(p.stock_quantity, 0)), 0),
-                        999.99
-                    ),
-                    0
-                ) as turnover_rate
-            FROM product_categories pc
-            JOIN products p ON pc.pid = p.pid
-            JOIN orders o ON p.pid = o.pid
-            WHERE o.canceled = false
-                AND o.date >= CURRENT_DATE - INTERVAL '12 months'
-            GROUP BY pc.cat_id, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone)
-            ON CONFLICT (category_id, year, month) DO UPDATE
-            SET
-                product_count = EXCLUDED.product_count,
-                active_products = EXCLUDED.active_products,
-                total_value = EXCLUDED.total_value,
-                total_revenue = EXCLUDED.total_revenue,
-                avg_margin = EXCLUDED.avg_margin,
-                turnover_rate = EXCLUDED.turnover_rate
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.99);
-        outputProgress({
-            status: 'running',
-            operation: 'Time-based metrics calculated, updating category-sales metrics',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Calculate category-sales metrics
-        await connection.query(`
-            INSERT INTO category_sales_metrics (
-                category_id,
-                brand,
-                period_start,
-                period_end,
-                avg_daily_sales,
-                total_sold,
-                num_products,
-                avg_price,
-                last_calculated_at
-            )
-            WITH date_ranges AS (
-                SELECT 
-                    CURRENT_DATE - INTERVAL '30 days' as period_start,
-                    CURRENT_DATE as period_end
-                UNION ALL
-                SELECT 
-                    CURRENT_DATE - INTERVAL '90 days',
-                    CURRENT_DATE - INTERVAL '31 days'
-                UNION ALL
-                SELECT 
-                    CURRENT_DATE - INTERVAL '180 days',
-                    CURRENT_DATE - INTERVAL '91 days'
-                UNION ALL
-                SELECT 
-                    CURRENT_DATE - INTERVAL '365 days',
-                    CURRENT_DATE - INTERVAL '181 days'
-            ),
-            sales_data AS (
-                SELECT 
-                    pc.cat_id,
-                    COALESCE(p.brand, 'Unknown') as brand,
-                    dr.period_start,
-                    dr.period_end,
-                    COUNT(DISTINCT p.pid) as num_products,
-                    SUM(o.quantity) as total_sold,
-                    SUM(o.quantity * o.price) as total_revenue,
-                    COUNT(DISTINCT DATE(o.date)) as num_days
-                FROM products p
-                JOIN product_categories pc ON p.pid = pc.pid
-                JOIN orders o ON p.pid = o.pid
-                CROSS JOIN date_ranges dr
-                WHERE o.canceled = false
-                    AND o.date BETWEEN dr.period_start AND dr.period_end
-                GROUP BY pc.cat_id, p.brand, dr.period_start, dr.period_end
-            )
-            SELECT 
-                cat_id as category_id,
-                brand,
-                period_start,
-                period_end,
-                CASE 
-                    WHEN num_days > 0 
-                    THEN total_sold / num_days 
-                    ELSE 0 
-                END as avg_daily_sales,
-                total_sold,
-                num_products,
-                CASE 
-                    WHEN total_sold > 0 
-                    THEN total_revenue / total_sold 
-                    ELSE 0 
-                END as avg_price,
-                NOW() as last_calculated_at
-            FROM sales_data
-            ON CONFLICT (category_id, brand, period_start, period_end) DO UPDATE
-            SET
-                avg_daily_sales = EXCLUDED.avg_daily_sales,
-                total_sold = EXCLUDED.total_sold,
-                num_products = EXCLUDED.num_products,
-                avg_price = EXCLUDED.avg_price,
-                last_calculated_at = EXCLUDED.last_calculated_at
-        `);
-
-        processedCount = Math.floor(totalProducts * 1.0);
-        outputProgress({
-            status: 'running',
-            operation: 'Category-sales metrics calculated',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // If we get here, everything completed successfully
-        success = true;
-        
-        // Update calculate_status
-        await connection.query(`
-            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
-            VALUES ('category_metrics', NOW())
-            ON CONFLICT (module_name) DO UPDATE
-            SET last_calculation_timestamp = NOW()
-        `);
-
-        return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-    } catch (error) {
-        success = false;
-        logError(error, 'Error calculating category metrics');
-        throw error;
-    } finally {
-        if (connection) {
-            connection.release();
-        }
-    }
-}
-
-module.exports = calculateCategoryMetrics; 

inventory-server/scripts/metrics/financial-metrics.js

@@ -1,195 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
-const { getConnection } = require('./utils/db');
-
-async function calculateFinancialMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
-    const connection = await getConnection();
-    let success = false;
-    let processedOrders = 0;
-    
-    try {
-        if (isCancelled) {
-            outputProgress({
-                status: 'cancelled',
-                operation: 'Financial metrics calculation cancelled',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: null,
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-            return {
-                processedProducts: processedCount,
-                processedOrders: 0,
-                processedPurchaseOrders: 0,
-                success
-            };
-        }
-
-        // Get order count that will be processed
-        const orderCount = await connection.query(`
-            SELECT COUNT(*) as count 
-            FROM orders o 
-            WHERE o.canceled = false
-                AND DATE(o.date) >= CURRENT_DATE - INTERVAL '12 months'
-        `);
-        processedOrders = parseInt(orderCount.rows[0].count);
-
-        outputProgress({
-            status: 'running',
-            operation: 'Starting financial metrics calculation',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // Calculate financial metrics with optimized query
-        await connection.query(`
-            WITH product_financials AS (
-                SELECT 
-                    p.pid,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    SUM(o.quantity * o.price) as total_revenue,
-                    SUM(o.quantity * p.cost_price) as cost_of_goods_sold,
-                    SUM(o.quantity * (o.price - p.cost_price)) as gross_profit,
-                    MIN(o.date) as first_sale_date,
-                    MAX(o.date) as last_sale_date,
-                    EXTRACT(DAY FROM (MAX(o.date)::timestamp with time zone - MIN(o.date)::timestamp with time zone)) + 1 as calculation_period_days,
-                    COUNT(DISTINCT DATE(o.date)) as active_days
-                FROM products p
-                LEFT JOIN orders o ON p.pid = o.pid
-                WHERE o.canceled = false
-                    AND DATE(o.date) >= CURRENT_DATE - INTERVAL '12 months'
-                GROUP BY p.pid, p.cost_price, p.stock_quantity
-            )
-            UPDATE product_metrics pm
-            SET 
-                inventory_value = COALESCE(pf.inventory_value, 0),
-                total_revenue = COALESCE(pf.total_revenue, 0),
-                cost_of_goods_sold = COALESCE(pf.cost_of_goods_sold, 0),
-                gross_profit = COALESCE(pf.gross_profit, 0),
-                gmroi = CASE 
-                    WHEN COALESCE(pf.inventory_value, 0) > 0 AND pf.active_days > 0 THEN 
-                        (COALESCE(pf.gross_profit, 0) * (365.0 / pf.active_days)) / COALESCE(pf.inventory_value, 0)
-                    ELSE 0 
-                END,
-                last_calculated_at = CURRENT_TIMESTAMP
-            FROM product_financials pf
-            WHERE pm.pid = pf.pid
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.65);
-        outputProgress({
-            status: 'running',
-            operation: 'Base financial metrics calculated, updating time aggregates',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Update time-based aggregates with optimized query
-        await connection.query(`
-            WITH monthly_financials AS (
-                SELECT 
-                    p.pid,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    SUM(o.quantity * (o.price - p.cost_price)) as gross_profit,
-                    COUNT(DISTINCT DATE(o.date)) as active_days,
-                    MIN(o.date) as period_start,
-                    MAX(o.date) as period_end
-                FROM products p
-                LEFT JOIN orders o ON p.pid = o.pid
-                WHERE o.canceled = false
-                GROUP BY p.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone), p.cost_price, p.stock_quantity
-            )
-            UPDATE product_time_aggregates pta
-            SET 
-                inventory_value = COALESCE(mf.inventory_value, 0),
-                gmroi = CASE 
-                    WHEN COALESCE(mf.inventory_value, 0) > 0 AND mf.active_days > 0 THEN 
-                        (COALESCE(mf.gross_profit, 0) * (365.0 / mf.active_days)) / COALESCE(mf.inventory_value, 0)
-                    ELSE 0 
-                END
-            FROM monthly_financials mf
-            WHERE pta.pid = mf.pid 
-                AND pta.year = mf.year 
-                AND pta.month = mf.month
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.70);
-        outputProgress({
-            status: 'running',
-            operation: 'Time-based aggregates updated',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // If we get here, everything completed successfully
-        success = true;
-        
-        // Update calculate_status
-        await connection.query(`
-            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
-            VALUES ('financial_metrics', NOW())
-            ON CONFLICT (module_name) DO UPDATE
-            SET last_calculation_timestamp = NOW()
-        `);
-
-        return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-    } catch (error) {
-        success = false;
-        logError(error, 'Error calculating financial metrics');
-        throw error;
-    } finally {
-        if (connection) {
-            connection.release();
-        }
-    }
-}
-
-module.exports = calculateFinancialMetrics; 

inventory-server/scripts/metrics/product-metrics.js

@@ -1,746 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
-const { getConnection } = require('./utils/db');
-
-// Helper function to handle NaN and undefined values
-function sanitizeValue(value) {
-    if (value === undefined || value === null || Number.isNaN(value)) {
-        return null;
-    }
-    return value;
-}
-
-async function calculateProductMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
-    let connection;
-    let success = false;
-    let processedOrders = 0;
-    const BATCH_SIZE = 5000;
-    
-    try {
-        connection = await getConnection();
-        // Skip flags are inherited from the parent scope
-        const SKIP_PRODUCT_BASE_METRICS = 0;
-        const SKIP_PRODUCT_TIME_AGGREGATES = 0;
-
-        // Get total product count if not provided
-        if (!totalProducts) {
-            const productCount = await connection.query('SELECT COUNT(*) as count FROM products');
-            totalProducts = parseInt(productCount.rows[0].count);
-        }
-
-        if (isCancelled) {
-            outputProgress({
-                status: 'cancelled',
-                operation: 'Product metrics calculation cancelled',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: null,
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-            return {
-                processedProducts: processedCount,
-                processedOrders,
-                processedPurchaseOrders: 0,
-                success
-            };
-        }
-
-        // First ensure all products have a metrics record
-        await connection.query(`
-            INSERT INTO product_metrics (pid, last_calculated_at)
-            SELECT pid, NOW()
-            FROM products
-            ON CONFLICT (pid) DO NOTHING
-        `);
-
-        // Get threshold settings once
-        const thresholds = await connection.query(`
-            SELECT critical_days, reorder_days, overstock_days, low_stock_threshold
-            FROM stock_thresholds 
-            WHERE category_id IS NULL AND vendor IS NULL
-            LIMIT 1
-        `);
-        const defaultThresholds = thresholds.rows[0];
-
-        // Calculate base product metrics
-        if (!SKIP_PRODUCT_BASE_METRICS) {
-            outputProgress({
-                status: 'running',
-                operation: 'Starting base product metrics calculation',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-
-            // Get order count that will be processed
-            const orderCount = await connection.query(`
-                SELECT COUNT(*) as count 
-                FROM orders o 
-                WHERE o.canceled = false
-            `);
-            processedOrders = parseInt(orderCount.rows[0].count);
-
-            // Clear temporary tables
-            await connection.query('DROP TABLE IF EXISTS temp_sales_metrics');
-            await connection.query('DROP TABLE IF EXISTS temp_purchase_metrics');
-
-            // Create temp_sales_metrics
-            await connection.query(`
-                CREATE TEMPORARY TABLE temp_sales_metrics (
-                    pid BIGINT NOT NULL,
-                    daily_sales_avg DECIMAL(10,3),
-                    weekly_sales_avg DECIMAL(10,3),
-                    monthly_sales_avg DECIMAL(10,3),
-                    total_revenue DECIMAL(10,3),
-                    avg_margin_percent DECIMAL(10,3),
-                    first_sale_date DATE,
-                    last_sale_date DATE,
-                    PRIMARY KEY (pid)
-                )
-            `);
-
-            // Create temp_purchase_metrics
-            await connection.query(`
-                CREATE TEMPORARY TABLE temp_purchase_metrics (
-                    pid BIGINT NOT NULL,
-                    avg_lead_time_days DOUBLE PRECISION,
-                    last_purchase_date DATE,
-                    first_received_date DATE,
-                    last_received_date DATE,
-                    PRIMARY KEY (pid)
-                )
-            `);
-
-            // Populate temp_sales_metrics with base stats and sales averages
-            await connection.query(`
-                INSERT INTO temp_sales_metrics
-                SELECT 
-                    p.pid,
-                    COALESCE(SUM(o.quantity) / NULLIF(COUNT(DISTINCT DATE(o.date)), 0), 0) as daily_sales_avg,
-                    COALESCE(SUM(o.quantity) / NULLIF(CEIL(COUNT(DISTINCT DATE(o.date)) / 7), 0), 0) as weekly_sales_avg,
-                    COALESCE(SUM(o.quantity) / NULLIF(CEIL(COUNT(DISTINCT DATE(o.date)) / 30), 0), 0) as monthly_sales_avg,
-                    COALESCE(SUM(o.quantity * o.price), 0) as total_revenue,
-                    CASE 
-                        WHEN SUM(o.quantity * o.price) > 0 
-                        THEN ((SUM(o.quantity * o.price) - SUM(o.quantity * p.cost_price)) / SUM(o.quantity * o.price)) * 100 
-                        ELSE 0 
-                    END as avg_margin_percent,
-                    MIN(o.date) as first_sale_date,
-                    MAX(o.date) as last_sale_date
-                FROM products p
-                LEFT JOIN orders o ON p.pid = o.pid 
-                    AND o.canceled = false
-                    AND o.date >= CURRENT_DATE - INTERVAL '90 days'
-                GROUP BY p.pid
-            `);
-
-            // Populate temp_purchase_metrics with timeout protection
-            await Promise.race([
-                connection.query(`
-                    INSERT INTO temp_purchase_metrics
-                    SELECT 
-                        p.pid,
-                        AVG(
-                            CASE 
-                                WHEN po.received_date IS NOT NULL AND po.date IS NOT NULL 
-                                THEN EXTRACT(EPOCH FROM (po.received_date::timestamp with time zone - po.date::timestamp with time zone)) / 86400.0
-                                ELSE NULL
-                            END
-                        ) as avg_lead_time_days,
-                        MAX(po.date) as last_purchase_date,
-                        MIN(po.received_date) as first_received_date,
-                        MAX(po.received_date) as last_received_date
-                    FROM products p
-                    LEFT JOIN purchase_orders po ON p.pid = po.pid 
-                        AND po.received_date IS NOT NULL
-                        AND po.date IS NOT NULL
-                        AND po.date >= CURRENT_DATE - INTERVAL '365 days'
-                    GROUP BY p.pid
-                `),
-                new Promise((_, reject) => 
-                    setTimeout(() => reject(new Error('Timeout: temp_purchase_metrics query took too long')), 60000)
-                )
-            ]).catch(async (err) => {
-                logError(err, 'Error populating temp_purchase_metrics, continuing with empty table');
-                // Create an empty fallback to continue processing
-                await connection.query(`
-                    INSERT INTO temp_purchase_metrics
-                    SELECT 
-                        p.pid,
-                        30.0 as avg_lead_time_days,
-                        NULL as last_purchase_date,
-                        NULL as first_received_date,
-                        NULL as last_received_date
-                    FROM products p
-                    LEFT JOIN temp_purchase_metrics tpm ON p.pid = tpm.pid
-                    WHERE tpm.pid IS NULL
-                `);
-            });
-
-            // Process updates in batches
-            let lastPid = 0;
-            let batchCount = 0;
-            const MAX_BATCHES = 1000; // Safety limit for number of batches to prevent infinite loops
-            
-            while (batchCount < MAX_BATCHES) {
-                if (isCancelled) break;
-                
-                batchCount++;
-                const batch = await connection.query(
-                    'SELECT pid FROM products WHERE pid > $1 ORDER BY pid LIMIT $2',
-                    [lastPid, BATCH_SIZE]
-                );
-
-                if (batch.rows.length === 0) break;
-
-                // Process the entire batch in a single efficient query
-                await connection.query(`
-                    UPDATE product_metrics pm
-                    SET 
-                        inventory_value = p.stock_quantity * NULLIF(p.cost_price, 0),
-                        daily_sales_avg = COALESCE(sm.daily_sales_avg, 0),
-                        weekly_sales_avg = COALESCE(sm.weekly_sales_avg, 0),
-                        monthly_sales_avg = COALESCE(sm.monthly_sales_avg, 0),
-                        total_revenue = COALESCE(sm.total_revenue, 0),
-                        avg_margin_percent = COALESCE(sm.avg_margin_percent, 0),
-                        first_sale_date = sm.first_sale_date,
-                        last_sale_date = sm.last_sale_date,
-                        avg_lead_time_days = COALESCE(lm.avg_lead_time_days, 30),
-                        days_of_inventory = CASE 
-                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 
-                            THEN FLOOR(p.stock_quantity / NULLIF(sm.daily_sales_avg, 0))
-                            ELSE NULL 
-                        END,
-                        weeks_of_inventory = CASE 
-                            WHEN COALESCE(sm.weekly_sales_avg, 0) > 0 
-                            THEN FLOOR(p.stock_quantity / NULLIF(sm.weekly_sales_avg, 0))
-                            ELSE NULL 
-                        END,
-                        stock_status = CASE
-                            WHEN p.stock_quantity <= 0 THEN 'Out of Stock'
-                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 AND p.stock_quantity <= $1 THEN 'Low Stock'
-                            WHEN COALESCE(sm.daily_sales_avg, 0) = 0 THEN 'In Stock'
-                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= $2 THEN 'Critical'
-                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) <= $3 THEN 'Reorder'
-                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > $4 THEN 'Overstocked'
-                            ELSE 'Healthy'
-                        END,
-                        safety_stock = CASE
-                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 THEN
-                                CEIL(sm.daily_sales_avg * SQRT(ABS(COALESCE(lm.avg_lead_time_days, 30))) * 1.96)
-                            ELSE $5
-                        END,
-                        reorder_point = CASE
-                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 THEN
-                                CEIL(sm.daily_sales_avg * COALESCE(lm.avg_lead_time_days, 30)) + 
-                                CEIL(sm.daily_sales_avg * SQRT(ABS(COALESCE(lm.avg_lead_time_days, 30))) * 1.96)
-                            ELSE $6
-                        END,
-                        reorder_qty = CASE
-                            WHEN COALESCE(sm.daily_sales_avg, 0) > 0 AND NULLIF(p.cost_price, 0) IS NOT NULL AND NULLIF(p.cost_price, 0) > 0 THEN
-                                GREATEST(
-                                    CEIL(SQRT(ABS((2 * (sm.daily_sales_avg * 365) * 25) / (NULLIF(p.cost_price, 0) * 0.25)))),
-                                    $7
-                                )
-                            ELSE $8
-                        END,
-                        overstocked_amt = CASE
-                            WHEN p.stock_quantity / NULLIF(sm.daily_sales_avg, 0) > $9 
-                            THEN GREATEST(0, p.stock_quantity - CEIL(sm.daily_sales_avg * $10))
-                            ELSE 0
-                        END,
-                        last_calculated_at = NOW()
-                    FROM products p
-                    LEFT JOIN temp_sales_metrics sm ON p.pid = sm.pid
-                    LEFT JOIN temp_purchase_metrics lm ON p.pid = lm.pid
-                    WHERE p.pid = ANY($11::bigint[])
-                    AND pm.pid = p.pid
-                `,
-                [
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.critical_days,
-                    defaultThresholds.reorder_days,
-                    defaultThresholds.overstock_days,
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.low_stock_threshold,
-                    defaultThresholds.overstock_days,
-                    defaultThresholds.overstock_days,
-                    batch.rows.map(row => row.pid)
-                ]);
-
-                lastPid = batch.rows[batch.rows.length - 1].pid;
-                processedCount += batch.rows.length;
-
-                outputProgress({
-                    status: 'running',
-                    operation: 'Processing base metrics batch',
-                    current: processedCount,
-                    total: totalProducts,
-                    elapsed: formatElapsedTime(startTime),
-                    remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                    rate: calculateRate(startTime, processedCount),
-                    percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                    timing: {
-                        start_time: new Date(startTime).toISOString(),
-                        end_time: new Date().toISOString(),
-                        elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                    }
-                });
-            }
-
-            // Add safety check if the loop processed MAX_BATCHES
-            if (batchCount >= MAX_BATCHES) {
-                logError(new Error(`Reached maximum batch count (${MAX_BATCHES}). Process may have entered an infinite loop.`), 'Batch processing safety limit reached');
-            }
-        }
-
-        // Calculate forecast accuracy and bias in batches
-        lastPid = 0;
-        while (true) {
-            if (isCancelled) break;
-
-            const batch = await connection.query(
-                'SELECT pid FROM products WHERE pid > $1 ORDER BY pid LIMIT $2',
-                [lastPid, BATCH_SIZE]
-            );
-
-            if (batch.rows.length === 0) break;
-
-            await connection.query(`
-                UPDATE product_metrics pm
-                SET 
-                    forecast_accuracy = GREATEST(0, 100 - LEAST(fa.avg_forecast_error, 100)),
-                    forecast_bias = GREATEST(-100, LEAST(fa.avg_forecast_bias, 100)),
-                    last_forecast_date = fa.last_forecast_date,
-                    last_calculated_at = NOW()
-                FROM (
-                    SELECT 
-                        sf.pid,
-                        AVG(CASE 
-                            WHEN o.quantity > 0 
-                            THEN ABS(sf.forecast_quantity - o.quantity) / o.quantity * 100
-                            ELSE 100 
-                        END) as avg_forecast_error,
-                        AVG(CASE 
-                            WHEN o.quantity > 0 
-                            THEN (sf.forecast_quantity - o.quantity) / o.quantity * 100
-                            ELSE 0 
-                        END) as avg_forecast_bias,
-                        MAX(sf.forecast_date) as last_forecast_date
-                    FROM sales_forecasts sf
-                    JOIN orders o ON sf.pid = o.pid 
-                        AND DATE(o.date) = sf.forecast_date
-                    WHERE o.canceled = false
-                        AND sf.forecast_date >= CURRENT_DATE - INTERVAL '90 days'
-                        AND sf.pid = ANY($1::bigint[])
-                    GROUP BY sf.pid
-                ) fa
-                WHERE pm.pid = fa.pid
-            `, [batch.rows.map(row => row.pid)]);
-
-            lastPid = batch.rows[batch.rows.length - 1].pid;
-        }
-
-        // Calculate product time aggregates
-        if (!SKIP_PRODUCT_TIME_AGGREGATES) {
-            outputProgress({
-                status: 'running',
-                operation: 'Starting product time aggregates calculation',
-                current: processedCount || 0,
-                total: totalProducts || 0,
-                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
-                rate: calculateRate(startTime, processedCount || 0),
-                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-
-            // Calculate time-based aggregates
-            await connection.query(`
-                INSERT INTO product_time_aggregates (
-                    pid,
-                    year,
-                    month,
-                    total_quantity_sold,
-                    total_revenue,
-                    total_cost,
-                    order_count,
-                    avg_price,
-                    profit_margin,
-                    inventory_value,
-                    gmroi
-                )
-                SELECT 
-                    p.pid,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    SUM(o.quantity) as total_quantity_sold,
-                    SUM(o.price * o.quantity) as total_revenue,
-                    SUM(p.cost_price * o.quantity) as total_cost,
-                    COUNT(DISTINCT o.order_number) as order_count,
-                    AVG(o.price) as avg_price,
-                    CASE 
-                        WHEN SUM(o.quantity * o.price) > 0 
-                        THEN ((SUM(o.quantity * o.price) - SUM(o.quantity * p.cost_price)) / SUM(o.quantity * o.price)) * 100
-                        ELSE 0 
-                    END as profit_margin,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    CASE 
-                        WHEN p.cost_price * p.stock_quantity > 0 
-                        THEN (SUM(o.quantity * (o.price - p.cost_price))) / (p.cost_price * p.stock_quantity)
-                        ELSE 0 
-                    END as gmroi
-                FROM products p
-                LEFT JOIN orders o ON p.pid = o.pid AND o.canceled = false
-                WHERE o.date >= CURRENT_DATE - INTERVAL '12 months'
-                GROUP BY p.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone)
-                ON CONFLICT (pid, year, month) DO UPDATE
-                SET
-                    total_quantity_sold = EXCLUDED.total_quantity_sold,
-                    total_revenue = EXCLUDED.total_revenue,
-                    total_cost = EXCLUDED.total_cost,
-                    order_count = EXCLUDED.order_count,
-                    avg_price = EXCLUDED.avg_price,
-                    profit_margin = EXCLUDED.profit_margin,
-                    inventory_value = EXCLUDED.inventory_value,
-                    gmroi = EXCLUDED.gmroi
-            `);
-
-            processedCount = Math.floor(totalProducts * 0.6);
-            outputProgress({
-                status: 'running',
-                operation: 'Product time aggregates calculated',
-                current: processedCount || 0,
-                total: totalProducts || 0,
-                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
-                rate: calculateRate(startTime, processedCount || 0),
-                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-        } else {
-            processedCount = Math.floor(totalProducts * 0.6);
-            outputProgress({
-                status: 'running',
-                operation: 'Skipping product time aggregates calculation',
-                current: processedCount || 0,
-                total: totalProducts || 0,
-                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount || 0, totalProducts || 0),
-                rate: calculateRate(startTime, processedCount || 0),
-                percentage: (((processedCount || 0) / (totalProducts || 1)) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-        }
-
-        // Calculate ABC classification
-        outputProgress({
-            status: 'running',
-            operation: 'Starting ABC classification',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,  // This module doesn't process POs
-            success
-        };
-
-        const abcConfig = await connection.query('SELECT a_threshold, b_threshold FROM abc_classification_config WHERE id = 1');
-        const abcThresholds = abcConfig.rows[0] || { a_threshold: 20, b_threshold: 50 };
-
-        // First, create and populate the rankings table with an index
-        await connection.query('DROP TABLE IF EXISTS temp_revenue_ranks');
-        await connection.query(`
-            CREATE TEMPORARY TABLE temp_revenue_ranks (
-                pid BIGINT NOT NULL,
-                total_revenue DECIMAL(10,3),
-                rank_num INT,
-                dense_rank_num INT,
-                percentile DECIMAL(5,2),
-                total_count INT,
-                PRIMARY KEY (pid)
-            )
-        `);
-        await connection.query('CREATE INDEX ON temp_revenue_ranks (rank_num)');
-        await connection.query('CREATE INDEX ON temp_revenue_ranks (dense_rank_num)');
-        await connection.query('CREATE INDEX ON temp_revenue_ranks (percentile)');
-
-        // Calculate rankings with proper tie handling
-        await connection.query(`
-            INSERT INTO temp_revenue_ranks
-            WITH revenue_data AS (
-                SELECT 
-                    pid,
-                    total_revenue,
-                    COUNT(*) OVER () as total_count,
-                    PERCENT_RANK() OVER (ORDER BY total_revenue DESC) * 100 as percentile,
-                    RANK() OVER (ORDER BY total_revenue DESC) as rank_num,
-                    DENSE_RANK() OVER (ORDER BY total_revenue DESC) as dense_rank_num
-                FROM product_metrics 
-                WHERE total_revenue > 0
-            )
-            SELECT 
-                pid,
-                total_revenue,
-                rank_num,
-                dense_rank_num,
-                percentile,
-                total_count
-            FROM revenue_data
-        `);
-
-        // Get total count for percentage calculation
-        const rankingCount = await connection.query('SELECT MAX(rank_num) as total_count FROM temp_revenue_ranks');
-        const totalCount = parseInt(rankingCount.rows[0].total_count) || 1;
-
-        // Process updates in batches
-        let abcProcessedCount = 0;
-        const batchSize = 5000;
-        const maxPid = await connection.query('SELECT MAX(pid) as max_pid FROM products');
-        const maxProductId = parseInt(maxPid.rows[0].max_pid);
-
-        while (abcProcessedCount < maxProductId) {
-            if (isCancelled) return {
-                processedProducts: processedCount,
-                processedOrders,
-                processedPurchaseOrders: 0,
-                success
-            };
-
-            // Get a batch of PIDs that need updating
-            const pids = await connection.query(`
-                SELECT pm.pid 
-                FROM product_metrics pm
-                LEFT JOIN temp_revenue_ranks tr ON pm.pid = tr.pid
-                WHERE pm.pid > $1
-                    AND (pm.abc_class IS NULL 
-                    OR pm.abc_class != 
-                        CASE 
-                            WHEN tr.pid IS NULL THEN 'C'
-                            WHEN tr.percentile <= $2 THEN 'A'
-                            WHEN tr.percentile <= $3 THEN 'B'
-                            ELSE 'C'
-                        END)
-                ORDER BY pm.pid
-                LIMIT $4
-            `, [abcProcessedCount, abcThresholds.a_threshold, abcThresholds.b_threshold, batchSize]);
-
-            if (pids.rows.length === 0) break;
-
-            const pidValues = pids.rows.map(row => row.pid);
-
-            await connection.query(`
-                UPDATE product_metrics pm
-                SET abc_class = 
-                    CASE 
-                        WHEN tr.pid IS NULL THEN 'C'
-                        WHEN tr.percentile <= $1 THEN 'A'
-                        WHEN tr.percentile <= $2 THEN 'B'
-                        ELSE 'C'
-                    END,
-                    last_calculated_at = NOW()
-                FROM (SELECT pid, percentile FROM temp_revenue_ranks) tr
-                WHERE pm.pid = tr.pid AND pm.pid = ANY($3::bigint[])
-                OR (pm.pid = ANY($3::bigint[]) AND tr.pid IS NULL)
-            `, [abcThresholds.a_threshold, abcThresholds.b_threshold, pidValues]);
-
-            // Now update turnover rate with proper handling of zero inventory periods
-            await connection.query(`
-                UPDATE product_metrics pm
-                SET 
-                    turnover_rate = CASE 
-                        WHEN sales.avg_nonzero_stock > 0 AND sales.active_days > 0 
-                        THEN LEAST(
-                            (sales.total_sold / sales.avg_nonzero_stock) * (365.0 / sales.active_days),
-                            999.99
-                        )
-                        ELSE 0 
-                    END,
-                    last_calculated_at = NOW()
-                FROM (
-                    SELECT 
-                        o.pid,
-                        SUM(o.quantity) as total_sold,
-                        COUNT(DISTINCT DATE(o.date)) as active_days,
-                        AVG(CASE 
-                            WHEN p.stock_quantity > 0 THEN p.stock_quantity 
-                            ELSE NULL 
-                        END) as avg_nonzero_stock
-                    FROM orders o
-                    JOIN products p ON o.pid = p.pid
-                    WHERE o.canceled = false 
-                    AND o.date >= CURRENT_DATE - INTERVAL '90 days'
-                    AND o.pid = ANY($1::bigint[])
-                    GROUP BY o.pid
-                ) sales
-                WHERE pm.pid = sales.pid
-            `, [pidValues]);
-
-            abcProcessedCount = pids.rows[pids.rows.length - 1].pid;
-            
-            // Calculate progress proportionally to total products
-            processedCount = Math.floor(totalProducts * (0.60 + (abcProcessedCount / maxProductId) * 0.2));
-            
-            outputProgress({
-                status: 'running',
-                operation: 'ABC classification progress',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: estimateRemaining(startTime, processedCount, totalProducts),
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-        }
-
-        // If we get here, everything completed successfully
-        success = true;
-        
-        // Update calculate_status
-        await connection.query(`
-            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
-            VALUES ('product_metrics', NOW())
-            ON CONFLICT (module_name) DO UPDATE
-            SET last_calculation_timestamp = NOW()
-        `);
-
-        return {
-            processedProducts: processedCount || 0,
-            processedOrders: processedOrders || 0,
-            processedPurchaseOrders: 0,  // This module doesn't process POs
-            success
-        };
-
-    } catch (error) {
-        success = false;
-        logError(error, 'Error calculating product metrics');
-        throw error;
-    } finally {
-        // Always clean up temporary tables, even if an error occurred
-        if (connection) {
-            try {
-                await connection.query('DROP TABLE IF EXISTS temp_sales_metrics');
-                await connection.query('DROP TABLE IF EXISTS temp_purchase_metrics');
-            } catch (err) {
-                console.error('Error cleaning up temporary tables:', err);
-            }
-            
-            // Make sure to release the connection
-            connection.release();
-        }
-    }
-}
-
-function calculateStockStatus(stock, config, daily_sales_avg, weekly_sales_avg, monthly_sales_avg) {
-    if (stock <= 0) {
-        return 'Out of Stock';
-    }
-
-    // Use the most appropriate sales average based on data quality
-    let sales_avg = daily_sales_avg;
-    if (sales_avg === 0) {
-        sales_avg = weekly_sales_avg / 7;
-    }
-    if (sales_avg === 0) {
-        sales_avg = monthly_sales_avg / 30;
-    }
-
-    if (sales_avg === 0) {
-        return stock <= config.low_stock_threshold ? 'Low Stock' : 'In Stock';
-    }
-
-    const days_of_stock = stock / sales_avg;
-
-    if (days_of_stock <= config.critical_days) {
-        return 'Critical';
-    } else if (days_of_stock <= config.reorder_days) {
-        return 'Reorder';
-    } else if (days_of_stock > config.overstock_days) {
-        return 'Overstocked';
-    }
-
-    return 'Healthy';
-}
-
-function calculateReorderQuantities(stock, stock_status, daily_sales_avg, avg_lead_time, config) {
-    // Calculate safety stock based on service level and lead time
-    const z_score = 1.96; // 95% service level
-    const lead_time = avg_lead_time || config.target_days;
-    const safety_stock = Math.ceil(daily_sales_avg * Math.sqrt(lead_time) * z_score);
-
-    // Calculate reorder point
-    const lead_time_demand = daily_sales_avg * lead_time;
-    const reorder_point = Math.ceil(lead_time_demand + safety_stock);
-
-    // Calculate reorder quantity using EOQ formula if we have the necessary data
-    let reorder_qty = 0;
-    if (daily_sales_avg > 0) {
-        const annual_demand = daily_sales_avg * 365;
-        const order_cost = 25; // Fixed cost per order
-        const holding_cost = config.cost_price * 0.25; // 25% of unit cost as annual holding cost
-        
-        reorder_qty = Math.ceil(Math.sqrt((2 * annual_demand * order_cost) / holding_cost));
-    } else {
-        // If no sales data, use a basic calculation
-        reorder_qty = Math.max(safety_stock, config.low_stock_threshold);
-    }
-
-    // Calculate overstocked amount
-    const overstocked_amt = stock_status === 'Overstocked' ? 
-        stock - Math.ceil(daily_sales_avg * config.overstock_days) : 
-        0;
-
-    return {
-        safety_stock,
-        reorder_point,
-        reorder_qty,
-        overstocked_amt
-    };
-}
-
-module.exports = calculateProductMetrics; 

inventory-server/scripts/metrics/sales-forecasts.js

@@ -1,435 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
-const { getConnection } = require('./utils/db');
-
-async function calculateSalesForecasts(startTime, totalProducts, processedCount = 0, isCancelled = false) {
-    const connection = await getConnection();
-    let success = false;
-    let processedOrders = 0;
-    
-    try {
-        if (isCancelled) {
-            outputProgress({
-                status: 'cancelled',
-                operation: 'Sales forecasts calculation cancelled',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: null,
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-            return {
-                processedProducts: processedCount,
-                processedOrders: 0,
-                processedPurchaseOrders: 0,
-                success
-            };
-        }
-
-        // Get order count that will be processed
-        const orderCount = await connection.query(`
-            SELECT COUNT(*) as count 
-            FROM orders o 
-            WHERE o.canceled = false
-                AND o.date >= CURRENT_DATE - INTERVAL '90 days'
-        `);
-        processedOrders = parseInt(orderCount.rows[0].count);
-
-        outputProgress({
-            status: 'running',
-            operation: 'Starting sales forecasts calculation',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // First, create a temporary table for forecast dates
-        await connection.query(`
-            CREATE TEMPORARY TABLE IF NOT EXISTS temp_forecast_dates (
-                forecast_date DATE,
-                day_of_week INT,
-                month INT,
-                PRIMARY KEY (forecast_date)
-            )
-        `);
-
-        await connection.query(`
-            INSERT INTO temp_forecast_dates
-            SELECT 
-                CURRENT_DATE + (n || ' days')::INTERVAL as forecast_date,
-                EXTRACT(DOW FROM CURRENT_DATE + (n || ' days')::INTERVAL) + 1 as day_of_week,
-                EXTRACT(MONTH FROM CURRENT_DATE + (n || ' days')::INTERVAL) as month
-            FROM (
-                SELECT a.n + b.n * 10 as n 
-                FROM 
-                    (SELECT 0 as n UNION SELECT 1 UNION SELECT 2 UNION SELECT 3 UNION SELECT 4 UNION
-                     SELECT 5 UNION SELECT 6 UNION SELECT 7 UNION SELECT 8 UNION SELECT 9) a,
-                    (SELECT 0 as n UNION SELECT 1 UNION SELECT 2) b
-                ORDER BY n
-                LIMIT 31
-            ) numbers
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.92);
-        outputProgress({
-            status: 'running',
-            operation: 'Forecast dates prepared, calculating daily sales stats',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Create temporary table for daily sales stats
-        await connection.query(`
-            CREATE TEMPORARY TABLE temp_daily_sales AS
-            SELECT 
-                o.pid,
-                EXTRACT(DOW FROM o.date) + 1 as day_of_week,
-                SUM(o.quantity) as daily_quantity,
-                SUM(o.price * o.quantity) as daily_revenue,
-                COUNT(DISTINCT DATE(o.date)) as day_count
-            FROM orders o
-            WHERE o.canceled = false
-                AND o.date >= CURRENT_DATE - INTERVAL '90 days'
-            GROUP BY o.pid, EXTRACT(DOW FROM o.date) + 1
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.94);
-        outputProgress({
-            status: 'running',
-            operation: 'Daily sales stats calculated, preparing product stats',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Create temporary table for product stats
-        await connection.query(`
-            CREATE TEMPORARY TABLE temp_product_stats AS
-            SELECT 
-                pid,
-                AVG(daily_revenue) as overall_avg_revenue,
-                SUM(day_count) as total_days
-            FROM temp_daily_sales
-            GROUP BY pid
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.96);
-        outputProgress({
-            status: 'running',
-            operation: 'Product stats prepared, calculating product-level forecasts',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Calculate product-level forecasts
-        await connection.query(`
-            INSERT INTO sales_forecasts (
-                pid,
-                forecast_date,
-                forecast_quantity,
-                confidence_level,
-                created_at
-            )
-            WITH daily_stats AS (
-                SELECT 
-                    ds.pid,
-                    AVG(ds.daily_quantity) as avg_daily_qty,
-                    STDDEV(ds.daily_quantity) as std_daily_qty,
-                    COUNT(DISTINCT ds.day_count) as data_points,
-                    SUM(ds.day_count) as total_days,
-                    AVG(ds.daily_revenue) as avg_daily_revenue,
-                    STDDEV(ds.daily_revenue) as std_daily_revenue,
-                    MIN(ds.daily_quantity) as min_daily_qty,
-                    MAX(ds.daily_quantity) as max_daily_qty,
-                    -- Calculate variance without using LAG
-                    COALESCE(
-                        STDDEV(ds.daily_quantity) / NULLIF(AVG(ds.daily_quantity), 0),
-                        0
-                    ) as daily_variance_ratio
-                FROM temp_daily_sales ds
-                GROUP BY ds.pid
-                HAVING AVG(ds.daily_quantity) > 0
-            )
-            SELECT 
-                ds.pid,
-                fd.forecast_date,
-                GREATEST(0, 
-                    ROUND(
-                        ds.avg_daily_qty * 
-                        (1 + COALESCE(sf.seasonality_factor, 0)) *
-                        CASE
-                            WHEN ds.std_daily_qty / NULLIF(ds.avg_daily_qty, 0) > 1.5 THEN 0.85
-                            WHEN ds.std_daily_qty / NULLIF(ds.avg_daily_qty, 0) > 1.0 THEN 0.9
-                            WHEN ds.std_daily_qty / NULLIF(ds.avg_daily_qty, 0) > 0.5 THEN 0.95
-                            ELSE 1.0
-                        END
-                    )
-                ) as forecast_quantity,
-                CASE
-                    WHEN ds.total_days >= 60 AND ds.daily_variance_ratio < 0.5 THEN 90
-                    WHEN ds.total_days >= 60 THEN 85
-                    WHEN ds.total_days >= 30 AND ds.daily_variance_ratio < 0.5 THEN 80
-                    WHEN ds.total_days >= 30 THEN 75
-                    WHEN ds.total_days >= 14 AND ds.daily_variance_ratio < 0.5 THEN 70
-                    WHEN ds.total_days >= 14 THEN 65
-                    ELSE 60
-                END as confidence_level,
-                NOW() as created_at
-            FROM daily_stats ds
-            JOIN temp_product_stats ps ON ds.pid = ps.pid
-            CROSS JOIN temp_forecast_dates fd
-            LEFT JOIN sales_seasonality sf ON fd.month = sf.month
-            GROUP BY ds.pid, fd.forecast_date, ps.overall_avg_revenue, sf.seasonality_factor, 
-                    ds.avg_daily_qty, ds.std_daily_qty, ds.avg_daily_qty, ds.total_days, ds.daily_variance_ratio
-            ON CONFLICT (pid, forecast_date) DO UPDATE
-            SET
-                forecast_quantity = EXCLUDED.forecast_quantity,
-                confidence_level = EXCLUDED.confidence_level,
-                created_at = NOW()
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.98);
-        outputProgress({
-            status: 'running',
-            operation: 'Product forecasts calculated, preparing category stats',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Create temporary table for category stats
-        await connection.query(`
-            CREATE TEMPORARY TABLE temp_category_sales AS
-            SELECT 
-                pc.cat_id,
-                EXTRACT(DOW FROM o.date) + 1 as day_of_week,
-                SUM(o.quantity) as daily_quantity,
-                SUM(o.price * o.quantity) as daily_revenue,
-                COUNT(DISTINCT DATE(o.date)) as day_count
-            FROM orders o
-            JOIN product_categories pc ON o.pid = pc.pid
-            WHERE o.canceled = false
-                AND o.date >= CURRENT_DATE - INTERVAL '90 days'
-            GROUP BY pc.cat_id, EXTRACT(DOW FROM o.date) + 1
-        `);
-
-        await connection.query(`
-            CREATE TEMPORARY TABLE temp_category_stats AS
-            SELECT 
-                cat_id,
-                AVG(daily_revenue) as overall_avg_revenue,
-                SUM(day_count) as total_days
-            FROM temp_category_sales
-            GROUP BY cat_id
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.99);
-        outputProgress({
-            status: 'running',
-            operation: 'Category stats prepared, calculating category-level forecasts',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Calculate category-level forecasts
-        await connection.query(`
-            INSERT INTO category_forecasts (
-                category_id,
-                forecast_date,
-                forecast_units,
-                forecast_revenue,
-                confidence_level,
-                created_at
-            )
-            SELECT 
-                cs.cat_id::bigint as category_id,
-                fd.forecast_date,
-                GREATEST(0, 
-                    AVG(cs.daily_quantity) * 
-                    (1 + COALESCE(sf.seasonality_factor, 0))
-                ) as forecast_units,
-                GREATEST(0, 
-                    COALESCE(
-                        CASE 
-                            WHEN SUM(cs.day_count) >= 4 THEN AVG(cs.daily_revenue)
-                            ELSE ct.overall_avg_revenue
-                        END * 
-                        (1 + COALESCE(sf.seasonality_factor, 0)) *
-                        (0.95 + (random() * 0.1)),
-                        0
-                    )
-                ) as forecast_revenue,
-                CASE
-                    WHEN ct.total_days >= 60 THEN 90
-                    WHEN ct.total_days >= 30 THEN 80
-                    WHEN ct.total_days >= 14 THEN 70
-                    ELSE 60
-                END as confidence_level,
-                NOW() as created_at
-            FROM temp_category_sales cs
-            JOIN temp_category_stats ct ON cs.cat_id = ct.cat_id
-            CROSS JOIN temp_forecast_dates fd
-            LEFT JOIN sales_seasonality sf ON fd.month = sf.month
-            GROUP BY 
-                cs.cat_id, 
-                fd.forecast_date, 
-                ct.overall_avg_revenue, 
-                ct.total_days, 
-                sf.seasonality_factor,
-                sf.month
-            HAVING AVG(cs.daily_quantity) > 0
-            ON CONFLICT (category_id, forecast_date) DO UPDATE
-            SET
-                forecast_units = EXCLUDED.forecast_units,
-                forecast_revenue = EXCLUDED.forecast_revenue,
-                confidence_level = EXCLUDED.confidence_level,
-                created_at = NOW()
-        `);
-
-        // Clean up temporary tables
-        await connection.query(`
-            DROP TABLE IF EXISTS temp_forecast_dates;
-            DROP TABLE IF EXISTS temp_daily_sales;
-            DROP TABLE IF EXISTS temp_product_stats;
-            DROP TABLE IF EXISTS temp_category_sales;
-            DROP TABLE IF EXISTS temp_category_stats;
-        `);
-
-        processedCount = Math.floor(totalProducts * 1.0);
-        outputProgress({
-            status: 'running',
-            operation: 'Category forecasts calculated and temporary tables cleaned up',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // If we get here, everything completed successfully
-        success = true;
-        
-        // Update calculate_status
-        await connection.query(`
-            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
-            VALUES ('sales_forecasts', NOW())
-            ON CONFLICT (module_name) DO UPDATE
-            SET last_calculation_timestamp = NOW()
-        `);
-
-        return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-    } catch (error) {
-        success = false;
-        logError(error, 'Error calculating sales forecasts');
-        throw error;
-    } finally {
-        if (connection) {
-            connection.release();
-        }
-    }
-}
-
-module.exports = calculateSalesForecasts; 

inventory-server/scripts/metrics/time-aggregates.js

@@ -1,306 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
-const { getConnection } = require('./utils/db');
-
-async function calculateTimeAggregates(startTime, totalProducts, processedCount = 0, isCancelled = false) {
-    const connection = await getConnection();
-    let success = false;
-    let processedOrders = 0;
-    
-    try {
-        if (isCancelled) {
-            outputProgress({
-                status: 'cancelled',
-                operation: 'Time aggregates calculation cancelled',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: null,
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-            return {
-                processedProducts: processedCount,
-                processedOrders: 0,
-                processedPurchaseOrders: 0,
-                success
-            };
-        }
-
-        // Get order count that will be processed
-        const orderCount = await connection.query(`
-            SELECT COUNT(*) as count 
-            FROM orders o 
-            WHERE o.canceled = false
-        `);
-        processedOrders = parseInt(orderCount.rows[0].count);
-
-        outputProgress({
-            status: 'running',
-            operation: 'Starting time aggregates calculation',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // Initial insert of time-based aggregates
-        await connection.query(`
-            INSERT INTO product_time_aggregates (
-                pid,
-                year,
-                month,
-                total_quantity_sold,
-                total_revenue,
-                total_cost,
-                order_count,
-                stock_received,
-                stock_ordered,
-                avg_price,
-                profit_margin,
-                inventory_value,
-                gmroi
-            )
-            WITH monthly_sales AS (
-                SELECT 
-                    o.pid,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    SUM(o.quantity) as total_quantity_sold,
-                    SUM((o.price - COALESCE(o.discount, 0)) * o.quantity) as total_revenue,
-                    SUM(COALESCE(p.cost_price, 0) * o.quantity) as total_cost,
-                    COUNT(DISTINCT o.order_number) as order_count,
-                    AVG(o.price - COALESCE(o.discount, 0)) as avg_price,
-                    CASE 
-                        WHEN SUM((o.price - COALESCE(o.discount, 0)) * o.quantity) > 0 
-                        THEN ((SUM((o.price - COALESCE(o.discount, 0)) * o.quantity) - SUM(COALESCE(p.cost_price, 0) * o.quantity)) 
-                            / SUM((o.price - COALESCE(o.discount, 0)) * o.quantity)) * 100
-                        ELSE 0 
-                    END as profit_margin,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    COUNT(DISTINCT DATE(o.date)) as active_days
-                FROM orders o
-                JOIN products p ON o.pid = p.pid
-                WHERE o.canceled = false
-                GROUP BY o.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone), p.cost_price, p.stock_quantity
-            ),
-            monthly_stock AS (
-                SELECT 
-                    pid,
-                    EXTRACT(YEAR FROM date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM date::timestamp with time zone) as month,
-                    SUM(received) as stock_received,
-                    SUM(ordered) as stock_ordered
-                FROM purchase_orders
-                GROUP BY pid, EXTRACT(YEAR FROM date::timestamp with time zone), EXTRACT(MONTH FROM date::timestamp with time zone)
-            ),
-            base_products AS (
-                SELECT 
-                    p.pid,
-                    p.cost_price * p.stock_quantity as inventory_value
-                FROM products p
-            )
-            SELECT 
-                COALESCE(s.pid, ms.pid) as pid,
-                COALESCE(s.year, ms.year) as year,
-                COALESCE(s.month, ms.month) as month,
-                COALESCE(s.total_quantity_sold, 0) as total_quantity_sold,
-                COALESCE(s.total_revenue, 0) as total_revenue,
-                COALESCE(s.total_cost, 0) as total_cost,
-                COALESCE(s.order_count, 0) as order_count,
-                COALESCE(ms.stock_received, 0) as stock_received,
-                COALESCE(ms.stock_ordered, 0) as stock_ordered,
-                COALESCE(s.avg_price, 0) as avg_price,
-                COALESCE(s.profit_margin, 0) as profit_margin,
-                COALESCE(s.inventory_value, bp.inventory_value, 0) as inventory_value,
-                CASE 
-                    WHEN COALESCE(s.inventory_value, bp.inventory_value, 0) > 0 
-                        AND COALESCE(s.active_days, 0) > 0 
-                    THEN (COALESCE(s.total_revenue - s.total_cost, 0) * (365.0 / s.active_days)) 
-                        / COALESCE(s.inventory_value, bp.inventory_value)
-                    ELSE 0 
-                END as gmroi
-            FROM (
-                SELECT * FROM monthly_sales s
-                UNION ALL
-                SELECT 
-                    ms.pid,
-                    ms.year,
-                    ms.month,
-                    0 as total_quantity_sold,
-                    0 as total_revenue,
-                    0 as total_cost,
-                    0 as order_count,
-                    NULL as avg_price,
-                    0 as profit_margin,
-                    NULL as inventory_value,
-                    0 as active_days
-                FROM monthly_stock ms
-                WHERE NOT EXISTS (
-                    SELECT 1 FROM monthly_sales s2
-                    WHERE s2.pid = ms.pid
-                    AND s2.year = ms.year
-                    AND s2.month = ms.month
-                )
-            ) s
-            LEFT JOIN monthly_stock ms 
-                ON s.pid = ms.pid 
-                AND s.year = ms.year 
-                AND s.month = ms.month
-            JOIN base_products bp ON COALESCE(s.pid, ms.pid) = bp.pid
-            UNION
-            SELECT 
-                ms.pid,
-                ms.year,
-                ms.month,
-                0 as total_quantity_sold,
-                0 as total_revenue,
-                0 as total_cost,
-                0 as order_count,
-                ms.stock_received,
-                ms.stock_ordered,
-                0 as avg_price,
-                0 as profit_margin,
-                bp.inventory_value,
-                0 as gmroi
-            FROM monthly_stock ms
-            JOIN base_products bp ON ms.pid = bp.pid
-            WHERE NOT EXISTS (
-                SELECT 1 FROM (
-                    SELECT * FROM monthly_sales
-                    UNION ALL
-                    SELECT 
-                        ms2.pid,
-                        ms2.year,
-                        ms2.month,
-                        0, 0, 0, 0, NULL, 0, NULL, 0
-                    FROM monthly_stock ms2
-                    WHERE NOT EXISTS (
-                        SELECT 1 FROM monthly_sales s2
-                        WHERE s2.pid = ms2.pid
-                        AND s2.year = ms2.year
-                        AND s2.month = ms2.month
-                    )
-                ) s
-                WHERE s.pid = ms.pid
-                AND s.year = ms.year
-                AND s.month = ms.month
-            )
-            ON CONFLICT (pid, year, month) DO UPDATE
-            SET
-                total_quantity_sold = EXCLUDED.total_quantity_sold,
-                total_revenue = EXCLUDED.total_revenue,
-                total_cost = EXCLUDED.total_cost,
-                order_count = EXCLUDED.order_count,
-                stock_received = EXCLUDED.stock_received,
-                stock_ordered = EXCLUDED.stock_ordered,
-                avg_price = EXCLUDED.avg_price,
-                profit_margin = EXCLUDED.profit_margin,
-                inventory_value = EXCLUDED.inventory_value,
-                gmroi = EXCLUDED.gmroi
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.60);
-        outputProgress({
-            status: 'running',
-            operation: 'Base time aggregates calculated, updating financial metrics',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-        // Update with financial metrics
-        await connection.query(`
-            UPDATE product_time_aggregates pta
-            SET inventory_value = COALESCE(fin.inventory_value, 0)
-            FROM (
-                SELECT 
-                    p.pid,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    p.cost_price * p.stock_quantity as inventory_value,
-                    SUM(o.quantity * (o.price - p.cost_price)) as gross_profit,
-                    COUNT(DISTINCT DATE(o.date)) as active_days
-                FROM products p
-                LEFT JOIN orders o ON p.pid = o.pid
-                WHERE o.canceled = false
-                GROUP BY p.pid, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone), p.cost_price, p.stock_quantity
-            ) fin
-            WHERE pta.pid = fin.pid 
-                AND pta.year = fin.year 
-                AND pta.month = fin.month
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.65);
-        outputProgress({
-            status: 'running',
-            operation: 'Financial metrics updated',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // If we get here, everything completed successfully
-        success = true;
-        
-        // Update calculate_status
-        await connection.query(`
-            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
-            VALUES ('time_aggregates', NOW())
-            ON CONFLICT (module_name) DO UPDATE
-            SET last_calculation_timestamp = NOW()
-        `);
-
-        return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders: 0,
-            success
-        };
-
-    } catch (error) {
-        success = false;
-        logError(error, 'Error calculating time aggregates');
-        throw error;
-    } finally {
-        if (connection) {
-            connection.release();
-        }
-    }
-}
-
-module.exports = calculateTimeAggregates; 

inventory-server/scripts/metrics/utils/db.js

@@ -1,39 +0,0 @@
-const { Pool } = require('pg');
-const path = require('path');
-require('dotenv').config({ path: path.resolve(__dirname, '../../..', '.env') });
-
-// Database configuration
-const dbConfig = {
-    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,
-    ssl: process.env.DB_SSL === 'true',
-    // Add performance optimizations
-    max: 10, // connection pool max size
-    idleTimeoutMillis: 30000,
-    connectionTimeoutMillis: 60000
-};
-
-// Create a single pool instance to be reused
-const pool = new Pool(dbConfig);
-
-// Add event handlers for pool
-pool.on('error', (err, client) => {
-    console.error('Unexpected error on idle client', err);
-});
-
-async function getConnection() {
-    return await pool.connect();
-}
-
-async function closePool() {
-    await pool.end();
-}
-
-module.exports = {
-    dbConfig,
-    getConnection,
-    closePool
-}; 

inventory-server/scripts/metrics/utils/progress.js

@@ -1,158 +0,0 @@
-const fs = require('fs');
-const path = require('path');
-
-// Helper function to format elapsed time
-function formatElapsedTime(elapsed) {
-    // If elapsed is a timestamp, convert to elapsed milliseconds
-    if (elapsed instanceof Date || elapsed > 1000000000000) {
-        elapsed = Date.now() - elapsed;
-    } else {
-        // If elapsed is in seconds, convert to milliseconds
-        elapsed = elapsed * 1000;
-    }
-    
-    const seconds = Math.floor(elapsed / 1000);
-    const minutes = Math.floor(seconds / 60);
-    const hours = Math.floor(minutes / 60);
-    
-    if (hours > 0) {
-        return `${hours}h ${minutes % 60}m`;
-    } else if (minutes > 0) {
-        return `${minutes}m ${seconds % 60}s`;
-    } else {
-        return `${seconds}s`;
-    }
-}
-
-// Helper function to estimate remaining time
-function estimateRemaining(startTime, current, total) {
-    if (current === 0) return null;
-    const elapsed = Date.now() - startTime;
-    const rate = current / elapsed;
-    const remaining = (total - current) / rate;
-    
-    const minutes = Math.floor(remaining / 60000);
-    const seconds = Math.floor((remaining % 60000) / 1000);
-    
-    if (minutes > 0) {
-        return `${minutes}m ${seconds}s`;
-    } else {
-        return `${seconds}s`;
-    }
-}
-
-// Helper function to calculate rate
-function calculateRate(startTime, current) {
-    const elapsed = (Date.now() - startTime) / 1000; // Convert to seconds
-    return elapsed > 0 ? Math.round(current / elapsed) : 0;
-}
-
-// Set up logging
-const LOG_DIR = path.join(__dirname, '../../../logs');
-const ERROR_LOG = path.join(LOG_DIR, 'import-errors.log');
-const IMPORT_LOG = path.join(LOG_DIR, 'import.log');
-const STATUS_FILE = path.join(LOG_DIR, 'metrics-status.json');
-
-// Ensure log directory exists
-if (!fs.existsSync(LOG_DIR)) {
-    fs.mkdirSync(LOG_DIR, { recursive: true });
-}
-
-// Helper function to log errors
-function logError(error, context = '') {
-    const timestamp = new Date().toISOString();
-    const errorMessage = `[${timestamp}] ${context}\nError: ${error.message}\nStack: ${error.stack}\n\n`;
-    
-    // Log to error file
-    fs.appendFileSync(ERROR_LOG, errorMessage);
-    
-    // Also log to console
-    console.error(`\n${context}\nError: ${error.message}`);
-}
-
-// Helper function to log import progress
-function logImport(message) {
-    const timestamp = new Date().toISOString();
-    const logMessage = `[${timestamp}] ${message}\n`;
-    fs.appendFileSync(IMPORT_LOG, logMessage);
-}
-
-// Helper function to output progress
-function outputProgress(data) {
-    // Save progress to file for resumption
-    saveProgress(data);
-    // Format as SSE event
-    const event = {
-        progress: data
-    };
-    // Always send to stdout for frontend
-    process.stdout.write(JSON.stringify(event) + '\n');
-    
-    // Log significant events to disk
-    const isSignificant = 
-        // Operation starts
-        (data.operation && !data.current) ||
-        // Operation completions and errors
-        data.status === 'complete' || 
-        data.status === 'error' ||
-        // Major phase changes
-        data.operation?.includes('Starting ABC classification') ||
-        data.operation?.includes('Starting time-based aggregates') ||
-        data.operation?.includes('Starting vendor metrics');
-    
-    if (isSignificant) {
-        logImport(`${data.operation || 'Operation'}${data.message ? ': ' + data.message : ''}${data.error ? ' Error: ' + data.error : ''}${data.status ? ' Status: ' + data.status : ''}`);
-    }
-}
-
-function saveProgress(progress) {
-    try {
-        fs.writeFileSync(STATUS_FILE, JSON.stringify({
-            ...progress,
-            timestamp: Date.now()
-        }));
-    } catch (err) {
-        console.error('Failed to save progress:', err);
-    }
-}
-
-function clearProgress() {
-    try {
-        if (fs.existsSync(STATUS_FILE)) {
-            fs.unlinkSync(STATUS_FILE);
-        }
-    } catch (err) {
-        console.error('Failed to clear progress:', err);
-    }
-}
-
-function getProgress() {
-    try {
-        if (fs.existsSync(STATUS_FILE)) {
-            const progress = JSON.parse(fs.readFileSync(STATUS_FILE, 'utf8'));
-            // Check if the progress is still valid (less than 1 hour old)
-            if (progress.timestamp && Date.now() - progress.timestamp < 3600000) {
-                return progress;
-            } else {
-                // Clear old progress
-                clearProgress();
-            }
-        }
-    } catch (err) {
-        console.error('Failed to read progress:', err);
-        clearProgress();
-    }
-    return null;
-}
-
-module.exports = {
-    formatElapsedTime,
-    estimateRemaining,
-    calculateRate,
-    logError,
-    logImport,
-    outputProgress,
-    saveProgress,
-    clearProgress,
-    getProgress
-}; 

inventory-server/scripts/metrics/vendor-metrics.js

@@ -1,378 +0,0 @@
-const { outputProgress, formatElapsedTime, estimateRemaining, calculateRate, logError } = require('./utils/progress');
-const { getConnection } = require('./utils/db');
-
-async function calculateVendorMetrics(startTime, totalProducts, processedCount = 0, isCancelled = false) {
-    const connection = await getConnection();
-    let success = false;
-    let processedOrders = 0;
-    let processedPurchaseOrders = 0;
-    
-    try {
-        if (isCancelled) {
-            outputProgress({
-                status: 'cancelled',
-                operation: 'Vendor metrics calculation cancelled',
-                current: processedCount,
-                total: totalProducts,
-                elapsed: formatElapsedTime(startTime),
-                remaining: null,
-                rate: calculateRate(startTime, processedCount),
-                percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-                timing: {
-                    start_time: new Date(startTime).toISOString(),
-                    end_time: new Date().toISOString(),
-                    elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-                }
-            });
-            return {
-                processedProducts: processedCount,
-                processedOrders,
-                processedPurchaseOrders,
-                success
-            };
-        }
-
-        // Get counts of records that will be processed
-        const [orderCountResult, poCountResult] = await Promise.all([
-            connection.query(`
-                SELECT COUNT(*) as count 
-                FROM orders o 
-                WHERE o.canceled = false
-            `),
-            connection.query(`
-                SELECT COUNT(*) as count 
-                FROM purchase_orders po 
-                WHERE po.status != 0
-            `)
-        ]);
-        processedOrders = parseInt(orderCountResult.rows[0].count);
-        processedPurchaseOrders = parseInt(poCountResult.rows[0].count);
-
-        outputProgress({
-            status: 'running',
-            operation: 'Starting vendor metrics calculation',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // First ensure all vendors exist in vendor_details
-        await connection.query(`
-            INSERT INTO vendor_details (vendor, status, created_at, updated_at)
-            SELECT DISTINCT 
-                vendor,
-                'active' as status,
-                NOW() as created_at,
-                NOW() as updated_at
-            FROM products
-            WHERE vendor IS NOT NULL
-            ON CONFLICT (vendor) DO NOTHING
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.8);
-        outputProgress({
-            status: 'running',
-            operation: 'Vendor details updated, calculating metrics',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders,
-            success
-        };
-
-        // Now calculate vendor metrics
-        await connection.query(`
-            INSERT INTO vendor_metrics (
-                vendor,
-                total_revenue,
-                total_orders,
-                total_late_orders,
-                avg_lead_time_days,
-                on_time_delivery_rate,
-                order_fill_rate,
-                avg_order_value,
-                active_products,
-                total_products,
-                total_purchase_value,
-                avg_margin_percent,
-                status,
-                last_calculated_at
-            )
-            WITH vendor_sales AS (
-                SELECT 
-                    p.vendor,
-                    SUM(o.quantity * o.price) as total_revenue,
-                    COUNT(DISTINCT o.id) as total_orders,
-                    COUNT(DISTINCT p.pid) as active_products,
-                    SUM(o.quantity * (o.price - p.cost_price)) as total_margin
-                FROM products p
-                JOIN orders o ON p.pid = o.pid
-                WHERE o.canceled = false
-                    AND o.date >= CURRENT_DATE - INTERVAL '12 months'
-                GROUP BY p.vendor
-            ),
-            vendor_po AS (
-                SELECT 
-                    p.vendor,
-                    COUNT(DISTINCT CASE WHEN po.receiving_status = 40 THEN po.id END) as received_orders,
-                    COUNT(DISTINCT po.id) as total_orders,
-                    AVG(CASE 
-                        WHEN po.receiving_status = 40 
-                            AND po.received_date IS NOT NULL 
-                            AND po.date IS NOT NULL
-                        THEN EXTRACT(EPOCH FROM (po.received_date::timestamp with time zone - po.date::timestamp with time zone)) / 86400.0
-                        ELSE NULL
-                    END) as avg_lead_time_days,
-                    SUM(po.ordered * po.po_cost_price) as total_purchase_value
-                FROM products p
-                JOIN purchase_orders po ON p.pid = po.pid
-                WHERE po.date >= CURRENT_DATE - INTERVAL '12 months'
-                GROUP BY p.vendor
-            ),
-            vendor_products AS (
-                SELECT 
-                    vendor,
-                    COUNT(DISTINCT pid) as total_products
-                FROM products
-                GROUP BY vendor
-            )
-            SELECT 
-                vs.vendor,
-                COALESCE(vs.total_revenue, 0) as total_revenue,
-                COALESCE(vp.total_orders, 0) as total_orders,
-                COALESCE(vp.total_orders - vp.received_orders, 0) as total_late_orders,
-                COALESCE(vp.avg_lead_time_days, 0) as avg_lead_time_days,
-                CASE 
-                    WHEN vp.total_orders > 0 
-                    THEN (vp.received_orders / vp.total_orders) * 100 
-                    ELSE 0 
-                END as on_time_delivery_rate,
-                CASE 
-                    WHEN vp.total_orders > 0 
-                    THEN (vp.received_orders / vp.total_orders) * 100 
-                    ELSE 0 
-                END as order_fill_rate,
-                CASE 
-                    WHEN vs.total_orders > 0 
-                    THEN vs.total_revenue / vs.total_orders 
-                    ELSE 0 
-                END as avg_order_value,
-                COALESCE(vs.active_products, 0) as active_products,
-                COALESCE(vpr.total_products, 0) as total_products,
-                COALESCE(vp.total_purchase_value, 0) as total_purchase_value,
-                CASE 
-                    WHEN vs.total_revenue > 0 
-                    THEN (vs.total_margin / vs.total_revenue) * 100 
-                    ELSE 0 
-                END as avg_margin_percent,
-                'active' as status,
-                NOW() as last_calculated_at
-            FROM vendor_sales vs
-            LEFT JOIN vendor_po vp ON vs.vendor = vp.vendor
-            LEFT JOIN vendor_products vpr ON vs.vendor = vpr.vendor
-            WHERE vs.vendor IS NOT NULL
-            ON CONFLICT (vendor) DO UPDATE
-            SET
-                total_revenue = EXCLUDED.total_revenue,
-                total_orders = EXCLUDED.total_orders,
-                total_late_orders = EXCLUDED.total_late_orders,
-                avg_lead_time_days = EXCLUDED.avg_lead_time_days,
-                on_time_delivery_rate = EXCLUDED.on_time_delivery_rate,
-                order_fill_rate = EXCLUDED.order_fill_rate,
-                avg_order_value = EXCLUDED.avg_order_value,
-                active_products = EXCLUDED.active_products,
-                total_products = EXCLUDED.total_products,
-                total_purchase_value = EXCLUDED.total_purchase_value,
-                avg_margin_percent = EXCLUDED.avg_margin_percent,
-                status = EXCLUDED.status,
-                last_calculated_at = EXCLUDED.last_calculated_at
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.9);
-        outputProgress({
-            status: 'running',
-            operation: 'Vendor metrics calculated, updating time-based metrics',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        if (isCancelled) return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders,
-            success
-        };
-
-        // Calculate time-based metrics
-        await connection.query(`
-            INSERT INTO vendor_time_metrics (
-                vendor,
-                year,
-                month,
-                total_orders,
-                late_orders,
-                avg_lead_time_days,
-                total_purchase_value,
-                total_revenue,
-                avg_margin_percent
-            )
-            WITH monthly_orders AS (
-                SELECT 
-                    p.vendor,
-                    EXTRACT(YEAR FROM o.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM o.date::timestamp with time zone) as month,
-                    COUNT(DISTINCT o.id) as total_orders,
-                    SUM(o.quantity * o.price) as total_revenue,
-                    SUM(o.quantity * (o.price - p.cost_price)) as total_margin
-                FROM products p
-                JOIN orders o ON p.pid = o.pid
-                WHERE o.canceled = false
-                    AND o.date >= CURRENT_DATE - INTERVAL '12 months'
-                    AND p.vendor IS NOT NULL
-                GROUP BY p.vendor, EXTRACT(YEAR FROM o.date::timestamp with time zone), EXTRACT(MONTH FROM o.date::timestamp with time zone)
-            ),
-            monthly_po AS (
-                SELECT 
-                    p.vendor,
-                    EXTRACT(YEAR FROM po.date::timestamp with time zone) as year,
-                    EXTRACT(MONTH FROM po.date::timestamp with time zone) as month,
-                    COUNT(DISTINCT po.id) as total_po,
-                    COUNT(DISTINCT CASE 
-                        WHEN po.receiving_status = 40 AND po.received_date > po.expected_date 
-                        THEN po.id 
-                    END) as late_orders,
-                    AVG(CASE 
-                        WHEN po.receiving_status = 40 
-                            AND po.received_date IS NOT NULL 
-                            AND po.date IS NOT NULL
-                        THEN EXTRACT(EPOCH FROM (po.received_date::timestamp with time zone - po.date::timestamp with time zone)) / 86400.0
-                        ELSE NULL
-                    END) as avg_lead_time_days,
-                    SUM(po.ordered * po.po_cost_price) as total_purchase_value
-                FROM products p
-                JOIN purchase_orders po ON p.pid = po.pid
-                WHERE po.date >= CURRENT_DATE - INTERVAL '12 months'
-                    AND p.vendor IS NOT NULL
-                GROUP BY p.vendor, EXTRACT(YEAR FROM po.date::timestamp with time zone), EXTRACT(MONTH FROM po.date::timestamp with time zone)
-            )
-            SELECT 
-                mo.vendor,
-                mo.year,
-                mo.month,
-                COALESCE(mp.total_po, 0) as total_orders,
-                COALESCE(mp.late_orders, 0) as late_orders,
-                COALESCE(mp.avg_lead_time_days, 0) as avg_lead_time_days,
-                COALESCE(mp.total_purchase_value, 0) as total_purchase_value,
-                mo.total_revenue,
-                CASE 
-                    WHEN mo.total_revenue > 0 
-                    THEN (mo.total_margin / mo.total_revenue) * 100 
-                    ELSE 0 
-                END as avg_margin_percent
-            FROM monthly_orders mo
-            LEFT JOIN monthly_po mp ON mo.vendor = mp.vendor 
-                AND mo.year = mp.year 
-                AND mo.month = mp.month
-            UNION
-            SELECT 
-                mp.vendor,
-                mp.year,
-                mp.month,
-                mp.total_po as total_orders,
-                mp.late_orders,
-                mp.avg_lead_time_days,
-                mp.total_purchase_value,
-                0 as total_revenue,
-                0 as avg_margin_percent
-            FROM monthly_po mp
-            LEFT JOIN monthly_orders mo ON mp.vendor = mo.vendor 
-                AND mp.year = mo.year 
-                AND mp.month = mo.month
-            WHERE mo.vendor IS NULL
-            ON CONFLICT (vendor, year, month) DO UPDATE
-            SET
-                total_orders = EXCLUDED.total_orders,
-                late_orders = EXCLUDED.late_orders,
-                avg_lead_time_days = EXCLUDED.avg_lead_time_days,
-                total_purchase_value = EXCLUDED.total_purchase_value,
-                total_revenue = EXCLUDED.total_revenue,
-                avg_margin_percent = EXCLUDED.avg_margin_percent
-        `);
-
-        processedCount = Math.floor(totalProducts * 0.95);
-        outputProgress({
-            status: 'running',
-            operation: 'Time-based vendor metrics calculated',
-            current: processedCount,
-            total: totalProducts,
-            elapsed: formatElapsedTime(startTime),
-            remaining: estimateRemaining(startTime, processedCount, totalProducts),
-            rate: calculateRate(startTime, processedCount),
-            percentage: ((processedCount / totalProducts) * 100).toFixed(1),
-            timing: {
-                start_time: new Date(startTime).toISOString(),
-                end_time: new Date().toISOString(),
-                elapsed_seconds: Math.round((Date.now() - startTime) / 1000)
-            }
-        });
-
-        // If we get here, everything completed successfully
-        success = true;
-        
-        // Update calculate_status
-        await connection.query(`
-            INSERT INTO calculate_status (module_name, last_calculation_timestamp)
-            VALUES ('vendor_metrics', NOW())
-            ON CONFLICT (module_name) DO UPDATE
-            SET last_calculation_timestamp = NOW()
-        `);
-
-        return {
-            processedProducts: processedCount,
-            processedOrders,
-            processedPurchaseOrders,
-            success
-        };
-
-    } catch (error) {
-        success = false;
-        logError(error, 'Error calculating vendor metrics');
-        throw error;
-    } finally {
-        if (connection) {
-            connection.release();
-        }
-    }
-}
-
-module.exports = calculateVendorMetrics;

inventory-server/scripts/reset-db.js

@@ -1,508 +0,0 @@
-const { Client } = require('pg');
-const path = require('path');
-const dotenv = require('dotenv');
-const fs = require('fs');
-
-dotenv.config({ path: path.join(__dirname, '../.env') });
-
-const dbConfig = {
-    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
-};
-
-// Helper function to output progress in JSON format
-function outputProgress(data) {
-    if (!data.status) {
-        data = {
-            status: 'running',
-            ...data
-        };
-    }
-    console.log(JSON.stringify(data));
-}
-
-// Core tables that must be created
-const CORE_TABLES = [
-    'products',
-    'orders',
-    'purchase_orders',
-    'categories',
-    'product_categories'
-];
-
-// Config tables that must be created
-const CONFIG_TABLES = [
-    'stock_thresholds',
-    'lead_time_thresholds',
-    'sales_velocity_config',
-    'abc_classification_config',
-    'safety_stock_config',
-    'sales_seasonality',
-    'turnover_config'
-];
-
-// Split SQL into individual statements
-function splitSQLStatements(sql) {
-    // First, normalize line endings
-    sql = sql.replace(/\r\n/g, '\n');
-    
-    // Track statement boundaries
-    let statements = [];
-    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 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;
-            } else if (char === stringChar) {
-                inString = false;
-            }
-        }
-        
-        // 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;
-            }
-        }
-        
-        // Handle statement boundaries (only if not in string or dollar quote)
-        if (!inString && !inDollarQuote && char === ';') {
-            if (currentStatement.trim()) {
-                statements.push(currentStatement.trim());
-            }
-            currentStatement = '';
-        } else {
-            currentStatement += char;
-        }
-    }
-    
-    // Add the last statement if it exists
-    if (currentStatement.trim()) {
-        statements.push(currentStatement.trim());
-    }
-    
-    return statements;
-}
-
-async function resetDatabase() {
-    outputProgress({
-        operation: 'Starting database reset',
-        message: 'Connecting to database...'
-    });
-
-    // Debug: Log current directory and file paths
-    outputProgress({
-        operation: 'Debug paths',
-        message: {
-            currentDir: process.cwd(),
-            __dirname: __dirname,
-            schemaPath: path.join(__dirname, '../db/schema.sql')
-        }
-    });
-
-    const client = new Client(dbConfig);
-    await client.connect();
-    
-    try {
-        // Check PostgreSQL version and user
-        outputProgress({
-            operation: 'Checking database',
-            message: 'Verifying PostgreSQL version and user privileges...'
-        });
-
-        const versionResult = await client.query('SELECT version()');
-        const userResult = await client.query('SELECT current_user, current_database()');
-        
-        outputProgress({
-            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
-        outputProgress({
-            operation: 'Getting table list',
-            message: 'Retrieving all table names...'
-        });
-
-        const tablesResult = await client.query(`
-            SELECT string_agg(tablename, ', ') as tables
-            FROM pg_tables
-            WHERE schemaname = 'public'
-            AND tablename NOT IN ('users', 'permissions', 'user_permissions', 'calculate_history', 'import_history', 'ai_prompts', 'ai_validation_performance', 'templates');
-        `);
-
-        if (!tablesResult.rows[0].tables) {
-            outputProgress({
-                operation: 'No tables found',
-                message: 'Database is already empty'
-            });
-        } else {
-            outputProgress({
-                operation: 'Dropping tables',
-                message: 'Dropping all existing tables...'
-            });
-
-            // 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\';');
-        }
-
-        // 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...'
-        });
-        const schemaPath = path.join(__dirname, '../db/schema.sql');
-        
-        // Verify file exists
-        if (!fs.existsSync(schemaPath)) {
-            throw new Error(`Schema file not found at: ${schemaPath}`);
-        }
-
-        const schemaSQL = fs.readFileSync(schemaPath, 'utf8');
-        
-        outputProgress({
-            operation: 'Schema file',
-            message: {
-                path: schemaPath,
-                exists: fs.existsSync(schemaPath),
-                size: fs.statSync(schemaPath).size,
-                firstFewLines: schemaSQL.split('\n').slice(0, 5).join('\n')
-            }
-        });
-
-        // Execute schema statements one at a time
-        const statements = splitSQLStatements(schemaSQL);
-        outputProgress({
-            operation: 'SQL Execution',
-            message: {
-                totalStatements: statements.length,
-                statements: statements.map((stmt, i) => ({
-                    number: i + 1,
-                    preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : '')
-                }))
-            }
-        });
-
-        for (let i = 0; i < statements.length; i++) {
-            const stmt = statements[i];
-            try {
-                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];
-                    if (tableName) {
-                        const tableExists = await client.query(`
-                            SELECT COUNT(*) as count 
-                            FROM information_schema.tables 
-                            WHERE table_schema = 'public' 
-                            AND table_name = $1
-                        `, [tableName]);
-                        
-                        outputProgress({
-                            operation: 'Table Creation Verification',
-                            message: {
-                                table: tableName,
-                                exists: tableExists.rows[0].count > 0
-                            }
-                        });
-                    }
-                }
-                
-                outputProgress({
-                    operation: 'SQL Progress',
-                    message: {
-                        statement: i + 1,
-                        total: statements.length,
-                        preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : ''),
-                        rowCount: result.rowCount
-                    }
-                });
-            } catch (sqlError) {
-                outputProgress({
-                    status: 'error',
-                    operation: 'SQL Error',
-                    error: sqlError.message,
-                    statement: stmt,
-                    statementNumber: i + 1
-                });
-                throw sqlError;
-            }
-        }
-
-        // Verify core tables were created
-        const existingTables = (await client.query(`
-            SELECT table_name
-            FROM information_schema.tables 
-            WHERE table_schema = 'public'
-        `)).rows.map(t => t.table_name);
-
-        outputProgress({
-            operation: 'Core tables verification',
-            message: {
-                found: existingTables,
-                expected: CORE_TABLES
-            }
-        });
-
-        const missingCoreTables = CORE_TABLES.filter(
-            t => !existingTables.includes(t)
-        );
-
-        if (missingCoreTables.length > 0) {
-            throw new Error(
-                `Failed to create core tables: ${missingCoreTables.join(', ')}`
-            );
-        }
-
-        outputProgress({
-            operation: 'Core tables created',
-            message: `Successfully created tables: ${CORE_TABLES.join(', ')}`
-        });
-
-        // Now read and execute config schema (since core tables exist)
-        outputProgress({
-            operation: 'Running config setup',
-            message: 'Creating configuration tables...'
-        });
-        const configSchemaSQL = fs.readFileSync(
-            path.join(__dirname, '../db/config-schema.sql'),
-            'utf8'
-        );
-        
-        // Execute config schema statements one at a time
-        const configStatements = splitSQLStatements(configSchemaSQL);
-        outputProgress({
-            operation: 'Config SQL Execution',
-            message: {
-                totalStatements: configStatements.length,
-                statements: configStatements.map((stmt, i) => ({
-                    number: i + 1,
-                    preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : '')
-                }))
-            }
-        });
-
-        for (let i = 0; i < configStatements.length; i++) {
-            const stmt = configStatements[i];
-            try {
-                const result = await client.query(stmt);
-                
-                outputProgress({
-                    operation: 'Config SQL Progress',
-                    message: {
-                        statement: i + 1,
-                        total: configStatements.length,
-                        preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : ''),
-                        rowCount: result.rowCount
-                    }
-                });
-            } catch (sqlError) {
-                outputProgress({
-                    status: 'error',
-                    operation: 'Config SQL Error',
-                    error: sqlError.message,
-                    statement: stmt,
-                    statementNumber: i + 1
-                });
-                throw sqlError;
-            }
-        }
-
-        // Read and execute metrics schema (metrics tables)
-        outputProgress({
-            operation: 'Running metrics setup',
-            message: 'Creating metrics tables...'
-        });
-        const metricsSchemaSQL = fs.readFileSync(
-            path.join(__dirname, '../db/metrics-schema.sql'),
-            'utf8'
-        );
-        
-        // Execute metrics schema statements one at a time
-        const metricsStatements = splitSQLStatements(metricsSchemaSQL);
-        outputProgress({
-            operation: 'Metrics SQL Execution',
-            message: {
-                totalStatements: metricsStatements.length,
-                statements: metricsStatements.map((stmt, i) => ({
-                    number: i + 1,
-                    preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : '')
-                }))
-            }
-        });
-
-        for (let i = 0; i < metricsStatements.length; i++) {
-            const stmt = metricsStatements[i];
-            try {
-                const result = await client.query(stmt);
-                
-                outputProgress({
-                    operation: 'Metrics SQL Progress',
-                    message: {
-                        statement: i + 1,
-                        total: metricsStatements.length,
-                        preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : ''),
-                        rowCount: result.rowCount
-                    }
-                });
-            } catch (sqlError) {
-                outputProgress({
-                    status: 'error',
-                    operation: 'Metrics SQL Error',
-                    error: sqlError.message,
-                    statement: stmt,
-                    statementNumber: i + 1
-                });
-                throw sqlError;
-            }
-        }
-
-        outputProgress({
-            status: 'complete',
-            operation: 'Database reset complete',
-            message: 'Database has been reset and all tables recreated'
-        });
-    } catch (error) {
-        outputProgress({
-            status: 'error',
-            operation: 'Failed to reset database',
-            error: error.message,
-            stack: error.stack
-        });
-        process.exit(1);
-    } finally {
-        await client.end();
-    }
-}
-
-// Export if required as a module
-if (typeof module !== 'undefined' && module.exports) {
-    module.exports = resetDatabase;
-}
-
-// Run if called directly
-if (require.main === module) {
-    resetDatabase().catch(error => {
-        console.error('Error:', error);
-        process.exit(1);
-    });
-} 

inventory-server/scripts/reset-metrics.js

@@ -1,355 +0,0 @@
-const { Client } = require('pg');
-const path = require('path');
-const fs = require('fs');
-require('dotenv').config({ path: path.resolve(__dirname, '../.env') });
-
-const dbConfig = {
-    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
-};
-
-function outputProgress(data) {
-    if (!data.status) {
-        data = {
-            status: 'running',
-            ...data
-        };
-    }
-    console.log(JSON.stringify(data));
-}
-
-// Explicitly define all metrics-related tables in dependency order
-const METRICS_TABLES = [
-    'brand_metrics',
-    'brand_time_metrics',
-    'category_forecasts',
-    'category_metrics',
-    'category_sales_metrics',
-    'category_time_metrics',
-    'product_metrics',
-    'product_time_aggregates',
-    'sales_forecasts',
-    'temp_purchase_metrics',
-    'temp_sales_metrics',
-    'vendor_metrics',
-    'vendor_time_metrics',
-    'vendor_details'
-];
-
-// Split SQL into individual statements
-function splitSQLStatements(sql) {
-    sql = sql.replace(/\r\n/g, '\n');
-    let statements = [];
-    let currentStatement = '';
-    let inString = false;
-    let stringChar = '';
-    
-    for (let i = 0; i < sql.length; i++) {
-        const char = sql[i];
-        const nextChar = sql[i + 1] || '';
-        
-        if ((char === "'" || char === '"') && sql[i - 1] !== '\\') {
-            if (!inString) {
-                inString = true;
-                stringChar = char;
-            } else if (char === stringChar) {
-                inString = false;
-            }
-        }
-        
-        if (!inString && char === '-' && nextChar === '-') {
-            while (i < sql.length && sql[i] !== '\n') i++;
-            continue;
-        }
-        
-        if (!inString && char === '/' && nextChar === '*') {
-            i += 2;
-            while (i < sql.length && (sql[i] !== '*' || sql[i + 1] !== '/')) i++;
-            i++;
-            continue;
-        }
-        
-        if (!inString && char === ';') {
-            if (currentStatement.trim()) {
-                statements.push(currentStatement.trim());
-            }
-            currentStatement = '';
-        } else {
-            currentStatement += char;
-        }
-    }
-    
-    if (currentStatement.trim()) {
-        statements.push(currentStatement.trim());
-    }
-    
-    return statements;
-}
-
-async function resetMetrics() {
-    let client;
-    try {
-        outputProgress({
-            operation: 'Starting metrics reset',
-            message: 'Connecting to database...'
-        });
-
-        client = new Client(dbConfig);
-        await client.connect();
-
-        // Explicitly begin a transaction
-        await client.query('BEGIN');
-
-        // First verify current state
-        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.rows.length} existing metrics tables: ${initialTables.rows.map(t => t.name).join(', ')}`
-        });
-
-        // Disable foreign key checks at the start
-        await client.query('SET session_replication_role = \'replica\'');
-
-        // Drop all metrics tables in reverse order to handle dependencies
-        outputProgress({
-            operation: 'Dropping metrics tables',
-            message: 'Removing existing metrics tables...'
-        });
-
-        for (const table of [...METRICS_TABLES].reverse()) {
-            try {
-                // Use NOWAIT to avoid hanging if there's a lock
-                await client.query(`DROP TABLE IF EXISTS "${table}" CASCADE`);
-                
-                // Verify the table was actually dropped
-                const checkDrop = await client.query(`
-                    SELECT COUNT(*) as count 
-                    FROM pg_tables 
-                    WHERE schemaname = 'public' 
-                    AND tablename = $1
-                `, [table]);
-                
-                if (parseInt(checkDrop.rows[0].count) > 0) {
-                    throw new Error(`Failed to drop table ${table} - table still exists`);
-                }
-
-                outputProgress({
-                    operation: 'Table dropped',
-                    message: `Successfully dropped table: ${table}`
-                });
-                
-                // Commit after each table drop to ensure locks are released
-                await client.query('COMMIT');
-                // Start a new transaction for the next table
-                await client.query('BEGIN');
-                // Re-disable foreign key constraints for the new transaction
-                await client.query('SET session_replication_role = \'replica\'');
-            } catch (err) {
-                outputProgress({
-                    status: 'error',
-                    operation: 'Drop table error',
-                    message: `Error dropping table ${table}: ${err.message}`
-                });
-                await client.query('ROLLBACK');
-                // Re-start transaction for next table
-                await client.query('BEGIN');
-                await client.query('SET session_replication_role = \'replica\'');
-            }
-        }
-
-        // Verify all tables were dropped
-        const afterDrop = await client.query(`
-            SELECT tablename as name
-            FROM pg_tables 
-            WHERE schemaname = 'public'
-            AND tablename = ANY($1)
-        `, [METRICS_TABLES]);
-
-        if (afterDrop.rows.length > 0) {
-            throw new Error(`Failed to drop all tables. Remaining tables: ${afterDrop.rows.map(t => t.name).join(', ')}`);
-        }
-
-        // Make sure we have a fresh transaction here
-        await client.query('COMMIT');
-        await client.query('BEGIN');
-        await client.query('SET session_replication_role = \'replica\'');
-
-        // Read metrics schema
-        outputProgress({
-            operation: 'Reading schema',
-            message: 'Loading metrics schema file...'
-        });
-
-        const schemaPath = path.resolve(__dirname, '../db/metrics-schema.sql');
-        if (!fs.existsSync(schemaPath)) {
-            throw new Error(`Schema file not found at: ${schemaPath}`);
-        }
-
-        const schemaSQL = fs.readFileSync(schemaPath, 'utf8');
-        const statements = splitSQLStatements(schemaSQL);
-
-        outputProgress({
-            operation: 'Schema loaded',
-            message: `Found ${statements.length} SQL statements to execute`
-        });
-
-        // Execute schema statements
-        for (let i = 0; i < statements.length; i++) {
-            const stmt = statements[i];
-            try {
-                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];
-                    if (tableName) {
-                        const checkCreate = await client.query(`
-                            SELECT tablename as name
-                            FROM pg_tables 
-                            WHERE schemaname = 'public' 
-                            AND tablename = $1
-                        `, [tableName]);
-                        
-                        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}`
-                        });
-                    }
-                }
-                
-                outputProgress({
-                    operation: 'SQL Progress',
-                    message: {
-                        statement: i + 1,
-                        total: statements.length,
-                        preview: stmt.substring(0, 100) + (stmt.length > 100 ? '...' : ''),
-                        rowCount: result.rowCount
-                    }
-                });
-                
-                // Commit every 10 statements to avoid long-running transactions
-                if (i > 0 && i % 10 === 0) {
-                    await client.query('COMMIT');
-                    await client.query('BEGIN');
-                    await client.query('SET session_replication_role = \'replica\'');
-                }
-            } catch (sqlError) {
-                outputProgress({
-                    status: 'error',
-                    operation: 'SQL Error',
-                    message: {
-                        error: sqlError.message,
-                        statement: stmt,
-                        statementNumber: i + 1
-                    }
-                });
-                await client.query('ROLLBACK');
-                throw sqlError;
-            }
-        }
-
-        // Final commit for any pending statements
-        await client.query('COMMIT');
-        
-        // Start new transaction for final checks
-        await client.query('BEGIN');
-
-        // Re-enable foreign key checks after all tables are created
-        await client.query('SET session_replication_role = \'origin\'');
-
-        // Verify metrics tables were created
-        outputProgress({
-            operation: 'Verifying metrics tables',
-            message: 'Checking all metrics tables were created...'
-        });
-
-        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.rows.length} tables: ${metricsTablesResult.rows.map(t => t.name).join(', ')}`
-        });
-
-        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 client.query(`
-                SELECT tablename as name
-                FROM pg_tables 
-                WHERE schemaname = 'public'
-            `);
-            outputProgress({
-                operation: 'Final table check',
-                message: `All database tables: ${finalCheck.rows.map(t => t.name).join(', ')}`
-            });
-            await client.query('ROLLBACK');
-            throw new Error(`Failed to create metrics tables: ${missingMetricsTables.join(', ')}`);
-        }
-
-        // Commit final transaction
-        await client.query('COMMIT');
-        
-        outputProgress({
-            status: 'complete',
-            operation: 'Reset complete',
-            message: 'All metrics tables have been reset successfully'
-        });
-    } catch (error) {
-        outputProgress({
-            status: 'error',
-            operation: 'Reset failed',
-            message: error.message,
-            stack: error.stack
-        });
-        
-        if (client) {
-            try {
-                await client.query('ROLLBACK');
-            } catch (rollbackError) {
-                console.error('Error during rollback:', rollbackError);
-            }
-            // Make sure to re-enable foreign key checks even if there's an error
-            await client.query('SET session_replication_role = \'origin\'').catch(() => {});
-        }
-        throw error;
-    } finally {
-        if (client) {
-            // One final attempt to ensure foreign key checks are enabled
-            await client.query('SET session_replication_role = \'origin\'').catch(() => {});
-            await client.end();
-        }
-    }
-}
-
-// Export if required as a module
-if (typeof module !== 'undefined' && module.exports) {
-    module.exports = resetMetrics;
-}
-
-// Run if called from command line
-if (require.main === module) {
-    resetMetrics().catch(error => {
-        console.error('Error:', error);
-        process.exit(1);
-    });
-} 

inventory-server/scripts/update-order-costs.js

@@ -1,337 +0,0 @@
-/**
- * This script updates the costeach values for existing orders from the original MySQL database
- * without needing to run the full import process.
- */
-const dotenv = require("dotenv");
-const path = require("path");
-const fs = require("fs");
-const { setupConnections, closeConnections } = require('./import/utils');
-const { outputProgress, formatElapsedTime } = require('./metrics/utils/progress');
-
-dotenv.config({ path: path.join(__dirname, "../.env") });
-
-// SSH configuration
-const sshConfig = {
-  ssh: {
-    host: process.env.PROD_SSH_HOST,
-    port: process.env.PROD_SSH_PORT || 22,
-    username: process.env.PROD_SSH_USER,
-    privateKey: process.env.PROD_SSH_KEY_PATH
-      ? fs.readFileSync(process.env.PROD_SSH_KEY_PATH)
-      : undefined,
-    compress: true, // 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,
-    database: process.env.PROD_DB_NAME,
-    port: process.env.PROD_DB_PORT || 3306,
-    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,
-    port: process.env.DB_PORT || 5432,
-    ssl: process.env.DB_SSL === 'true',
-    connectionTimeoutMillis: 60000,
-    idleTimeoutMillis: 30000,
-    max: 10 // connection pool max size
-  }
-};
-
-async function updateOrderCosts() {
-  const startTime = Date.now();
-  let connections;
-  let updatedCount = 0;
-  let errorCount = 0;
-
-  try {
-    outputProgress({
-      status: "running",
-      operation: "Order costs update",
-      message: "Initializing SSH tunnel..."
-    });
-
-    connections = await setupConnections(sshConfig);
-    const { prodConnection, localConnection } = connections;
-
-    // 1. Get all orders from local database that need cost updates
-    outputProgress({
-      status: "running",
-      operation: "Order costs update",
-      message: "Getting orders from local database..."
-    });
-
-    const [orders] = await localConnection.query(`
-      SELECT DISTINCT order_number, pid 
-      FROM orders 
-      WHERE costeach = 0 OR costeach IS NULL
-      ORDER BY order_number
-    `);
-
-    if (!orders || !orders.rows || orders.rows.length === 0) {
-      console.log("No orders found that need cost updates");
-      return { updatedCount: 0, errorCount: 0 };
-    }
-
-    const totalOrders = orders.rows.length;
-    console.log(`Found ${totalOrders} orders that need cost updates`);
-
-    // Process in batches of 1000 orders
-    const BATCH_SIZE = 500;
-    for (let i = 0; i < orders.rows.length; i += BATCH_SIZE) {
-      try {
-        // Start transaction for this batch
-        await localConnection.beginTransaction();
-        
-        const batch = orders.rows.slice(i, i + BATCH_SIZE);
-        
-        const orderNumbers = [...new Set(batch.map(o => o.order_number))];
-        
-        // 2. Fetch costs from production database for these orders
-        outputProgress({
-          status: "running",
-          operation: "Order costs update",
-          message: `Fetching costs for orders ${i + 1} to ${Math.min(i + BATCH_SIZE, totalOrders)} of ${totalOrders}`,
-          current: i,
-          total: totalOrders,
-          elapsed: formatElapsedTime((Date.now() - startTime) / 1000)
-        });
-
-        const [costs] = await prodConnection.query(`
-          SELECT 
-            oc.orderid as order_number,
-            oc.pid,
-            oc.costeach
-          FROM order_costs oc
-          INNER JOIN (
-            SELECT 
-              orderid,
-              pid, 
-              MAX(id) as max_id
-            FROM order_costs
-            WHERE orderid IN (?) 
-              AND pending = 0
-            GROUP BY orderid, pid
-          ) latest ON oc.orderid = latest.orderid AND oc.pid = latest.pid AND oc.id = latest.max_id
-        `, [orderNumbers]);
-
-        // Create a map of costs for easy lookup
-        const costMap = {};
-        if (costs && costs.length) {
-          costs.forEach(c => {
-            costMap[`${c.order_number}-${c.pid}`] = c.costeach || 0;
-          });
-        }
-
-        // 3. Update costs in local database by batches
-        // Using a more efficient update approach with a temporary table
-        
-        // Create a temporary table for each batch
-        await localConnection.query(`
-          DROP TABLE IF EXISTS temp_order_costs;
-          CREATE TEMP TABLE temp_order_costs (
-            order_number VARCHAR(50) NOT NULL,
-            pid BIGINT NOT NULL,
-            costeach DECIMAL(10,3) NOT NULL,
-            PRIMARY KEY (order_number, pid)
-          );
-        `);
-        
-        // Insert cost data into the temporary table
-        const costEntries = [];
-        for (const order of batch) {
-          const key = `${order.order_number}-${order.pid}`;
-          if (key in costMap) {
-            costEntries.push({
-              order_number: order.order_number,
-              pid: order.pid,
-              costeach: costMap[key]
-            });
-          }
-        }
-        
-        // Insert in sub-batches of 100
-        const DB_BATCH_SIZE = 50;
-        for (let j = 0; j < costEntries.length; j += DB_BATCH_SIZE) {
-          const subBatch = costEntries.slice(j, j + DB_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(item => [
-            item.order_number,
-            item.pid,
-            item.costeach
-          ]);
-          
-          await localConnection.query(`
-            INSERT INTO temp_order_costs (order_number, pid, costeach)
-            VALUES ${placeholders}
-          `, values);
-        }
-        
-        // Perform bulk update from the temporary table
-        const [updateResult] = await localConnection.query(`
-          UPDATE orders o
-          SET costeach = t.costeach
-          FROM temp_order_costs t
-          WHERE o.order_number = t.order_number AND o.pid = t.pid
-          RETURNING o.id
-        `);
-        
-        const batchUpdated = updateResult.rowCount || 0;
-        updatedCount += batchUpdated;
-
-        // Commit transaction for this batch
-        await localConnection.commit();
-
-        outputProgress({
-          status: "running",
-          operation: "Order costs update",
-          message: `Updated ${updatedCount} orders with costs from production (batch: ${batchUpdated})`,
-          current: i + batch.length,
-          total: totalOrders,
-          elapsed: formatElapsedTime((Date.now() - startTime) / 1000)
-        });
-      } catch (error) {
-        // If a batch fails, roll back that batch's transaction and continue
-        try {
-          await localConnection.rollback();
-        } catch (rollbackError) {
-          console.error("Error during batch rollback:", rollbackError);
-        }
-        
-        console.error(`Error processing batch ${i}-${i + BATCH_SIZE}:`, error);
-        errorCount++;
-      }
-    }
-
-    // 4. For orders with no matching costs, set a default based on price
-    outputProgress({
-      status: "running",
-      operation: "Order costs update",
-      message: "Setting default costs for remaining orders..."
-    });
-
-    // Process remaining updates in smaller batches
-    const DEFAULT_BATCH_SIZE = 10000;
-    let totalDefaultUpdated = 0;
-    
-    try {
-      // Start with a count query to determine how many records need the default update
-      const [countResult] = await localConnection.query(`
-        SELECT COUNT(*) as count FROM orders
-        WHERE (costeach = 0 OR costeach IS NULL)
-      `);
-      
-      const totalToUpdate = parseInt(countResult.rows[0]?.count || 0);
-      
-      if (totalToUpdate > 0) {
-        console.log(`Applying default cost to ${totalToUpdate} orders`);
-        
-        // Apply the default in batches with separate transactions
-        for (let i = 0; i < totalToUpdate; i += DEFAULT_BATCH_SIZE) {
-          try {
-            await localConnection.beginTransaction();
-            
-            const [defaultUpdates] = await localConnection.query(`
-              WITH orders_to_update AS (
-                SELECT id FROM orders
-                WHERE (costeach = 0 OR costeach IS NULL)
-                LIMIT ${DEFAULT_BATCH_SIZE}
-              )
-              UPDATE orders o
-              SET costeach = price * 0.5
-              FROM orders_to_update otu
-              WHERE o.id = otu.id
-              RETURNING o.id
-            `);
-            
-            const batchDefaultUpdated = defaultUpdates.rowCount || 0;
-            totalDefaultUpdated += batchDefaultUpdated;
-            
-            await localConnection.commit();
-            
-            outputProgress({
-              status: "running",
-              operation: "Order costs update",
-              message: `Applied default costs to ${totalDefaultUpdated} of ${totalToUpdate} orders`,
-              current: totalDefaultUpdated,
-              total: totalToUpdate,
-              elapsed: formatElapsedTime((Date.now() - startTime) / 1000)
-            });
-          } catch (error) {
-            try {
-              await localConnection.rollback();
-            } catch (rollbackError) {
-              console.error("Error during default update rollback:", rollbackError);
-            }
-            
-            console.error(`Error applying default costs batch ${i}-${i + DEFAULT_BATCH_SIZE}:`, error);
-            errorCount++;
-          }
-        }
-      }
-    } catch (error) {
-      console.error("Error counting or updating remaining orders:", error);
-      errorCount++;
-    }
-
-    updatedCount += totalDefaultUpdated;
-    
-    const endTime = Date.now();
-    const totalSeconds = (endTime - startTime) / 1000;
-
-    outputProgress({
-      status: "complete",
-      operation: "Order costs update",
-      message: `Updated ${updatedCount} orders (${totalDefaultUpdated} with default values) in ${formatElapsedTime(totalSeconds)}`,
-      elapsed: formatElapsedTime(totalSeconds)
-    });
-
-    return {
-      status: "complete",
-      updatedCount,
-      errorCount
-    };
-  } catch (error) {
-    console.error("Error during order costs update:", error);
-    
-    return {
-      status: "error",
-      error: error.message,
-      updatedCount,
-      errorCount
-    };
-  } finally {
-    if (connections) {
-      await closeConnections(connections).catch(err => {
-        console.error("Error closing connections:", err);
-      });
-    }
-  }
-}
-
-// Run the script only if this is the main module
-if (require.main === module) {
-  updateOrderCosts().then((results) => {
-    console.log('Cost update completed:', results);
-    // Force exit after a small delay to ensure all logs are written
-    setTimeout(() => process.exit(0), 500);
-  }).catch((error) => {
-    console.error("Unhandled error:", error);
-    // Force exit with error code after a small delay
-    setTimeout(() => process.exit(1), 500);
-  });
-}
-
-// Export the function for use in other scripts
-module.exports = updateOrderCosts; 

inventory-server/src/middleware/cors.js

@@ -4,7 +4,9 @@ const cors = require('cors');
 const corsMiddleware = cors({
   origin: [
     'https://inventory.kent.pw',
-    'http://localhost:5173',
+    'http://localhost:5175',
+    'https://tools.acherryontop.com',
+    'https://tools.acherryontop.com',
     /^http:\/\/192\.168\.\d+\.\d+(:\d+)?$/,
     /^http:\/\/10\.\d+\.\d+\.\d+(:\d+)?$/
   ],
@@ -26,7 +28,7 @@ const corsErrorHandler = (err, req, res, next) => {
     res.status(403).json({
       error: 'CORS not allowed',
       origin: req.get('Origin'),
-      message: 'Origin not in allowed list: https://inventory.kent.pw, localhost:5173, 192.168.x.x, or 10.x.x.x'
+      message: 'Origin not in allowed list: https://inventory.kent.pw, https://tools.acherryontop.com, https://tools.acherryontop.com, localhost:5175, 192.168.x.x, or 10.x.x.x'
     });
   } else {
     next(err);

inventory-server/src/routes/ai-prompts.js

@@ -1,335 +0,0 @@
-const express = require('express');
-const router = express.Router();
-
-// Get all AI prompts
-router.get('/', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      SELECT * FROM ai_prompts 
-      ORDER BY prompt_type ASC, company ASC
-    `);
-    res.json(result.rows);
-  } catch (error) {
-    console.error('Error fetching AI prompts:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch AI prompts',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Get prompt by ID
-router.get('/:id', async (req, res) => {
-  try {
-    const { id } = req.params;
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      SELECT * FROM ai_prompts 
-      WHERE id = $1
-    `, [id]);
-
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'AI prompt not found' });
-    }
-
-    res.json(result.rows[0]);
-  } catch (error) {
-    console.error('Error fetching AI prompt:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch AI prompt',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Get prompt by company
-router.get('/company/:companyId', async (req, res) => {
-  try {
-    const { companyId } = req.params;
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      SELECT * FROM ai_prompts 
-      WHERE company = $1
-    `, [companyId]);
-
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'AI prompt not found for this company' });
-    }
-
-    res.json(result.rows[0]);
-  } catch (error) {
-    console.error('Error fetching AI prompt by company:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch AI prompt by company',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Get general prompt
-router.get('/type/general', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      SELECT * FROM ai_prompts 
-      WHERE prompt_type = 'general'
-    `);
-
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'General AI prompt not found' });
-    }
-
-    res.json(result.rows[0]);
-  } catch (error) {
-    console.error('Error fetching general AI prompt:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch general AI prompt',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Get system prompt
-router.get('/type/system', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      SELECT * FROM ai_prompts 
-      WHERE prompt_type = 'system'
-    `);
-
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'System AI prompt not found' });
-    }
-
-    res.json(result.rows[0]);
-  } catch (error) {
-    console.error('Error fetching system AI prompt:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch system AI prompt',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Create new AI prompt
-router.post('/', async (req, res) => {
-  try {
-    const {
-      prompt_text,
-      prompt_type,
-      company
-    } = req.body;
-
-    // Validate required fields
-    if (!prompt_text || !prompt_type) {
-      return res.status(400).json({ error: 'Prompt text and type are required' });
-    }
-    
-    // Validate prompt type
-    if (!['general', 'company_specific', 'system'].includes(prompt_type)) {
-      return res.status(400).json({ error: 'Prompt type must be either "general", "company_specific", or "system"' });
-    }
-    
-    // Validate company is provided for company-specific prompts
-    if (prompt_type === 'company_specific' && !company) {
-      return res.status(400).json({ error: 'Company is required for company-specific prompts' });
-    }
-
-    // Validate company is not provided for general or system prompts
-    if ((prompt_type === 'general' || prompt_type === 'system') && company) {
-      return res.status(400).json({ error: 'Company should not be provided for general or system prompts' });
-    }
-
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      INSERT INTO ai_prompts (
-        prompt_text,
-        prompt_type,
-        company
-      ) VALUES ($1, $2, $3)
-      RETURNING *
-    `, [
-      prompt_text,
-      prompt_type,
-      company
-    ]);
-
-    res.status(201).json(result.rows[0]);
-  } catch (error) {
-    console.error('Error creating AI prompt:', error);
-    
-    // Check for unique constraint violations
-    if (error instanceof Error && error.message.includes('unique constraint')) {
-      if (error.message.includes('unique_company_prompt')) {
-        return res.status(409).json({ 
-          error: 'A prompt already exists for this company',
-          details: error.message
-        });
-      } else if (error.message.includes('idx_unique_general_prompt')) {
-        return res.status(409).json({ 
-          error: 'A general prompt already exists',
-          details: error.message
-        });
-      } else if (error.message.includes('idx_unique_system_prompt')) {
-        return res.status(409).json({ 
-          error: 'A system prompt already exists',
-          details: error.message
-        });
-      }
-    }
-    
-    res.status(500).json({ 
-      error: 'Failed to create AI prompt',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Update AI prompt
-router.put('/:id', async (req, res) => {
-  try {
-    const { id } = req.params;
-    const {
-      prompt_text,
-      prompt_type,
-      company
-    } = req.body;
-
-    // Validate required fields
-    if (!prompt_text || !prompt_type) {
-      return res.status(400).json({ error: 'Prompt text and type are required' });
-    }
-    
-    // Validate prompt type
-    if (!['general', 'company_specific', 'system'].includes(prompt_type)) {
-      return res.status(400).json({ error: 'Prompt type must be either "general", "company_specific", or "system"' });
-    }
-    
-    // Validate company is provided for company-specific prompts
-    if (prompt_type === 'company_specific' && !company) {
-      return res.status(400).json({ error: 'Company is required for company-specific prompts' });
-    }
-    
-    // Validate company is not provided for general or system prompts
-    if ((prompt_type === 'general' || prompt_type === 'system') && company) {
-      return res.status(400).json({ error: 'Company should not be provided for general or system prompts' });
-    }
-
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    // Check if the prompt exists
-    const checkResult = await pool.query('SELECT * FROM ai_prompts WHERE id = $1', [id]);
-    if (checkResult.rows.length === 0) {
-      return res.status(404).json({ error: 'AI prompt not found' });
-    }
-    
-    const result = await pool.query(`
-      UPDATE ai_prompts 
-      SET 
-        prompt_text = $1,
-        prompt_type = $2,
-        company = $3
-      WHERE id = $4
-      RETURNING *
-    `, [
-      prompt_text,
-      prompt_type,
-      company,
-      id
-    ]);
-
-    res.json(result.rows[0]);
-  } catch (error) {
-    console.error('Error updating AI prompt:', error);
-    
-    // Check for unique constraint violations
-    if (error instanceof Error && error.message.includes('unique constraint')) {
-      if (error.message.includes('unique_company_prompt')) {
-        return res.status(409).json({ 
-          error: 'A prompt already exists for this company',
-          details: error.message
-        });
-      } else if (error.message.includes('idx_unique_general_prompt')) {
-        return res.status(409).json({ 
-          error: 'A general prompt already exists',
-          details: error.message
-        });
-      } else if (error.message.includes('idx_unique_system_prompt')) {
-        return res.status(409).json({ 
-          error: 'A system prompt already exists',
-          details: error.message
-        });
-      }
-    }
-    
-    res.status(500).json({ 
-      error: 'Failed to update AI prompt',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Delete AI prompt
-router.delete('/:id', async (req, res) => {
-  try {
-    const { id } = req.params;
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query('DELETE FROM ai_prompts WHERE id = $1 RETURNING *', [id]);
-
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'AI prompt not found' });
-    }
-
-    res.json({ message: 'AI prompt deleted successfully' });
-  } catch (error) {
-    console.error('Error deleting AI prompt:', error);
-    res.status(500).json({ 
-      error: 'Failed to delete AI prompt',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Error handling middleware
-router.use((err, req, res, next) => {
-  console.error('AI prompts route error:', err);
-  res.status(500).json({ 
-    error: 'Internal server error',
-    details: err.message
-  });
-});
-
-module.exports = router; 

inventory-server/src/routes/analytics.js

@@ -1,783 +1 @@
-const express = require('express');
-const router = express.Router();
-
-// Get overall analytics stats
-router.get('/stats', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    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)::numeric, 1
-          ),
-          0
-        ) as profitMargin,
-        COALESCE(
-          ROUND(
-            (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))::numeric, 2
-          ),
-          0
-        ) as stockTurnoverRate,
-        COALESCE(COUNT(DISTINCT p.vendor), 0) as vendorCount,
-        COALESCE(COUNT(DISTINCT p.categories), 0) as categoryCount,
-        COALESCE(
-          ROUND(
-            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 >= CURRENT_DATE - INTERVAL '30 days'
-    `);
-
-    // Ensure all values are numbers
-    const stats = {
-      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);
-  } catch (error) {
-    console.error('Error fetching analytics stats:', error);
-    res.status(500).json({ error: 'Failed to fetch analytics stats' });
-  }
-});
-
-// Get profit analysis data
-router.get('/profit', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    // Get profit margins by category with full path
-    const { rows: byCategory } = await pool.query(`
-      WITH RECURSIVE category_path AS (
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          c.name::text as path
-        FROM categories c
-        WHERE c.parent_id IS NULL
-        
-        UNION ALL
-        
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          (cp.path || ' > ' || c.name)::text
-        FROM categories c
-        JOIN category_path cp ON c.parent_id = cp.cat_id
-      )
-      SELECT 
-        c.name as category,
-        cp.path as categoryPath,
-        ROUND(
-          (SUM(o.price * o.quantity - p.cost_price * o.quantity) / 
-           NULLIF(SUM(o.price * o.quantity), 0) * 100)::numeric, 1
-        ) as profitMargin,
-        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 >= CURRENT_DATE - INTERVAL '30 days'
-      GROUP BY c.name, cp.path
-      ORDER BY profitMargin DESC
-      LIMIT 10
-    `);
-
-    // Get profit margin trend over time
-    const { rows: overTime } = await pool.query(`
-      SELECT 
-        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)::numeric, 1
-        ) as profitMargin,
-        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
-      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 { rows: topProducts } = await pool.query(`
-      WITH RECURSIVE category_path AS (
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          c.name::text as path
-        FROM categories c
-        WHERE c.parent_id IS NULL
-        
-        UNION ALL
-        
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          (cp.path || ' > ' || c.name)::text
-        FROM categories c
-        JOIN category_path cp ON c.parent_id = cp.cat_id
-      )
-      SELECT 
-        p.title as product,
-        c.name as category,
-        cp.path as categoryPath,
-        ROUND(
-          (SUM(o.price * o.quantity - p.cost_price * o.quantity) / 
-           NULLIF(SUM(o.price * o.quantity), 0) * 100)::numeric, 1
-        ) as profitMargin,
-        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 >= CURRENT_DATE - INTERVAL '30 days'
-      GROUP BY p.pid, p.title, c.name, cp.path
-      HAVING SUM(o.price * o.quantity) > 0
-      ORDER BY profitMargin DESC
-      LIMIT 10
-    `);
-
-    res.json({ byCategory, overTime, topProducts });
-  } catch (error) {
-    console.error('Error fetching profit analysis:', error);
-    res.status(500).json({ error: 'Failed to fetch profit analysis' });
-  }
-});
-
-// Get vendor performance data
-router.get('/vendors', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    // Set cache control headers to prevent 304
-    res.set({
-      'Cache-Control': 'no-cache, no-store, must-revalidate',
-      'Pragma': 'no-cache',
-      'Expires': '0'
-    });
-    
-    console.log('Fetching vendor performance data...');
-
-    // First check if we have any vendors with sales
-    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
-      LEFT JOIN orders o ON p.pid = o.pid
-      WHERE p.vendor IS NOT NULL
-    `);
-    
-    console.log('Vendor data check:', checkData);
-    
-    // Get vendor performance metrics
-    const { rows: rawPerformance } = await pool.query(`
-      WITH monthly_sales AS (
-        SELECT 
-          p.vendor,
-          ROUND(SUM(CASE 
-            WHEN o.date >= CURRENT_DATE - INTERVAL '30 days'
-            THEN o.price * o.quantity 
-            ELSE 0 
-          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)::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 >= CURRENT_DATE - INTERVAL '60 days'
-        GROUP BY p.vendor
-      )
-      SELECT 
-        p.vendor,
-        ROUND(SUM(o.price * o.quantity)::numeric, 3) as sales_volume,
-        COALESCE(ROUND(
-          (SUM(o.price * o.quantity - p.cost_price * o.quantity) / 
-           NULLIF(SUM(o.price * o.quantity), 0) * 100)::numeric, 1
-        ), 0) as profit_margin,
-        COALESCE(ROUND(
-          (SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0))::numeric, 1
-        ), 0) as stock_turnover,
-        COUNT(DISTINCT p.pid) as product_count,
-        ROUND(
-          ((ms.current_month / NULLIF(ms.previous_month, 0)) - 1) * 100,
-          1
-        ) as growth
-      FROM products p
-      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 >= CURRENT_DATE - INTERVAL '30 days'
-      GROUP BY p.vendor, ms.current_month, ms.previous_month
-      ORDER BY sales_volume DESC
-      LIMIT 10
-    `);
-
-    // Transform to camelCase properties for frontend consumption
-    const performance = rawPerformance.map(item => ({
-      vendor: item.vendor,
-      salesVolume: Number(item.sales_volume) || 0,
-      profitMargin: Number(item.profit_margin) || 0,
-      stockTurnover: Number(item.stock_turnover) || 0,
-      productCount: Number(item.product_count) || 0,
-      growth: Number(item.growth) || 0
-    }));
-
-    // Get vendor comparison metrics (sales per product vs margin)
-    const { rows: rawComparison } = await pool.query(`
-      SELECT 
-        p.vendor,
-        COALESCE(ROUND(
-          SUM(o.price * o.quantity) / NULLIF(COUNT(DISTINCT p.pid), 0), 
-          2
-        ), 0) as sales_per_product,
-        COALESCE(ROUND(
-          AVG((p.price - p.cost_price) / NULLIF(p.cost_price, 0) * 100), 
-          2
-        ), 0) as average_margin,
-        COUNT(DISTINCT p.pid) as size
-      FROM products p
-      LEFT JOIN orders o ON p.pid = o.pid
-      WHERE p.vendor IS NOT NULL
-        AND o.date >= CURRENT_DATE - INTERVAL '30 days'
-      GROUP BY p.vendor
-      HAVING COUNT(DISTINCT p.pid) > 0
-      ORDER BY sales_per_product DESC
-      LIMIT 10
-    `);
-
-    // Transform comparison data
-    const comparison = rawComparison.map(item => ({
-      vendor: item.vendor,
-      salesPerProduct: Number(item.sales_per_product) || 0,
-      averageMargin: Number(item.average_margin) || 0,
-      size: Number(item.size) || 0
-    }));
-
-    console.log('Performance data ready. Sending response...');
-
-    // Return complete structure that the front-end expects
-    res.json({ 
-      performance,
-      comparison,
-      // Add empty trends array to complete the structure
-      trends: []
-    });
-  } catch (error) {
-    console.error('Error fetching vendor performance:', error);
-    console.error('Error details:', error.message);
-    
-    // Return dummy data on error with complete structure
-    res.json({ 
-      performance: [
-        {
-          vendor: "Example Vendor 1",
-          salesVolume: 10000,
-          profitMargin: 25.5,
-          stockTurnover: 3.2,
-          productCount: 15,
-          growth: 12.3
-        },
-        {
-          vendor: "Example Vendor 2",
-          salesVolume: 8500,
-          profitMargin: 22.8,
-          stockTurnover: 2.9,
-          productCount: 12,
-          growth: 8.7
-        },
-        {
-          vendor: "Example Vendor 3",
-          salesVolume: 6200,
-          profitMargin: 19.5,
-          stockTurnover: 2.5,
-          productCount: 8,
-          growth: 5.2
-        }
-      ],
-      comparison: [
-        {
-          vendor: "Example Vendor 1",
-          salesPerProduct: 650,
-          averageMargin: 35.2,
-          size: 15
-        },
-        {
-          vendor: "Example Vendor 2",
-          salesPerProduct: 710,
-          averageMargin: 28.5,
-          size: 12
-        },
-        {
-          vendor: "Example Vendor 3",
-          salesPerProduct: 770,
-          averageMargin: 22.8,
-          size: 8
-        }
-      ],
-      trends: []
-    });
-  }
-});
-
-// Get stock analysis data
-router.get('/stock', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    // Get global configuration values
-    const { rows: configs } = await pool.query(`
-      SELECT 
-        st.low_stock_threshold,
-        tc.calculation_period_days as turnover_period
-      FROM stock_thresholds st
-      CROSS JOIN turnover_config tc
-      WHERE st.id = 1 AND tc.id = 1
-    `);
-    
-    const config = configs[0] || {
-      low_stock_threshold: 5,
-      turnover_period: 30
-    };
-    
-    // Get turnover by category
-    const { rows: turnoverByCategory } = await pool.query(`
-      SELECT 
-        c.name as category,
-        ROUND((SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0))::numeric, 1) as turnoverRate,
-        ROUND(AVG(p.stock_quantity)::numeric, 0) as averageStock,
-        SUM(o.quantity) as totalSales
-      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
-      WHERE o.date >= CURRENT_DATE - INTERVAL '${config.turnover_period} days'
-      GROUP BY c.name
-      HAVING ROUND((SUM(o.quantity) / NULLIF(AVG(p.stock_quantity), 0))::numeric, 1) > 0
-      ORDER BY turnoverRate DESC
-      LIMIT 10
-    `);
-
-    // Get stock levels over time
-    const { rows: stockLevels } = await pool.query(`
-      SELECT 
-        to_char(o.date, 'YYYY-MM-DD') as date,
-        SUM(CASE WHEN p.stock_quantity > $1 THEN 1 ELSE 0 END) as inStock,
-        SUM(CASE WHEN p.stock_quantity <= $1 AND p.stock_quantity > 0 THEN 1 ELSE 0 END) as lowStock,
-        SUM(CASE WHEN p.stock_quantity = 0 THEN 1 ELSE 0 END) as outOfStock
-      FROM products p
-      LEFT JOIN orders o ON p.pid = o.pid
-      WHERE o.date >= CURRENT_DATE - INTERVAL '${config.turnover_period} days'
-      GROUP BY to_char(o.date, 'YYYY-MM-DD')
-      ORDER BY date
-    `, [config.low_stock_threshold]);
-
-    // Get critical stock items
-    const { rows: criticalItems } = await pool.query(`
-      WITH product_thresholds AS (
-        SELECT 
-          p.pid,
-          COALESCE(
-            (SELECT reorder_days 
-             FROM stock_thresholds st 
-             WHERE st.vendor = p.vendor LIMIT 1),
-            (SELECT reorder_days 
-             FROM stock_thresholds st 
-             WHERE st.vendor IS NULL LIMIT 1),
-            14
-          ) as reorder_days
-        FROM products p
-      )
-      SELECT 
-        p.title as product,
-        p.SKU as sku,
-        p.stock_quantity as stockQuantity,
-        GREATEST(ROUND((AVG(o.quantity) * pt.reorder_days)::numeric), $1) as reorderPoint,
-        ROUND((SUM(o.quantity) / NULLIF(p.stock_quantity, 0))::numeric, 1) as turnoverRate,
-        CASE 
-          WHEN p.stock_quantity = 0 THEN 0
-          ELSE ROUND((p.stock_quantity / NULLIF((SUM(o.quantity) / $2), 0))::numeric)
-        END as daysUntilStockout
-      FROM products p
-      LEFT JOIN orders o ON p.pid = o.pid
-      JOIN product_thresholds pt ON p.pid = pt.pid
-      WHERE o.date >= CURRENT_DATE - INTERVAL '${config.turnover_period} days'
-        AND p.managing_stock = true
-      GROUP BY p.pid, pt.reorder_days
-      HAVING 
-        CASE 
-          WHEN p.stock_quantity = 0 THEN 0
-          ELSE ROUND((p.stock_quantity / NULLIF((SUM(o.quantity) / $2), 0))::numeric)
-        END < $3 
-        AND 
-        CASE 
-          WHEN p.stock_quantity = 0 THEN 0
-          ELSE ROUND((p.stock_quantity / NULLIF((SUM(o.quantity) / $2), 0))::numeric)
-        END >= 0
-      ORDER BY daysUntilStockout
-      LIMIT 10
-    `, [
-      config.low_stock_threshold,
-      config.turnover_period,
-      config.turnover_period
-    ]);
-
-    res.json({ turnoverByCategory, stockLevels, criticalItems });
-  } catch (error) {
-    console.error('Error fetching stock analysis:', error);
-    res.status(500).json({ error: 'Failed to fetch stock analysis' });
-  }
-});
-
-// Get price analysis data
-router.get('/pricing', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    // Get price points analysis
-    const { rows: pricePoints } = await pool.query(`
-      SELECT 
-        CAST(p.price AS DECIMAL(15,3)) as price,
-        CAST(SUM(o.quantity) AS DECIMAL(15,3)) as salesVolume,
-        CAST(SUM(o.price * o.quantity) AS DECIMAL(15,3)) as revenue,
-        c.name as category
-      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
-      WHERE o.date >= CURRENT_DATE - INTERVAL '30 days'
-      GROUP BY p.price, c.name
-      HAVING SUM(o.quantity) > 0
-      ORDER BY revenue DESC
-      LIMIT 50
-    `);
-
-    // Get price elasticity data (price changes vs demand)
-    const { rows: elasticity } = await pool.query(`
-      SELECT 
-        to_char(o.date, 'YYYY-MM-DD') as date,
-        CAST(AVG(o.price) AS DECIMAL(15,3)) as price,
-        CAST(SUM(o.quantity) AS DECIMAL(15,3)) as demand
-      FROM orders o
-      WHERE o.date >= CURRENT_DATE - INTERVAL '30 days'
-      GROUP BY to_char(o.date, 'YYYY-MM-DD')
-      ORDER BY date
-    `);
-
-    // Get price optimization recommendations
-    const { rows: recommendations } = await pool.query(`
-      SELECT 
-        p.title as product,
-        CAST(p.price AS DECIMAL(15,3)) as currentPrice,
-        CAST(
-          ROUND(
-            CASE 
-              WHEN AVG(o.quantity) > 10 THEN p.price * 1.1
-              WHEN AVG(o.quantity) < 2 THEN p.price * 0.9
-              ELSE p.price
-            END, 2
-          ) AS DECIMAL(15,3)
-        ) as recommendedPrice,
-        CAST(
-          ROUND(
-            SUM(o.price * o.quantity) * 
-            CASE 
-              WHEN AVG(o.quantity) > 10 THEN 1.15
-              WHEN AVG(o.quantity) < 2 THEN 0.95
-              ELSE 1
-            END, 2
-          ) AS DECIMAL(15,3)
-        ) as potentialRevenue,
-        CASE 
-          WHEN AVG(o.quantity) > 10 THEN 85
-          WHEN AVG(o.quantity) < 2 THEN 75
-          ELSE 65
-        END as confidence
-      FROM products p
-      LEFT JOIN orders o ON p.pid = o.pid
-      WHERE o.date >= CURRENT_DATE - INTERVAL '30 days'
-      GROUP BY p.pid, p.price, p.title
-      HAVING ABS(
-        CAST(
-          ROUND(
-            CASE 
-              WHEN AVG(o.quantity) > 10 THEN p.price * 1.1
-              WHEN AVG(o.quantity) < 2 THEN p.price * 0.9
-              ELSE p.price
-            END, 2
-          ) AS DECIMAL(15,3)
-        ) - CAST(p.price AS DECIMAL(15,3))
-      ) > 0
-      ORDER BY 
-        CAST(
-          ROUND(
-            SUM(o.price * o.quantity) * 
-            CASE 
-              WHEN AVG(o.quantity) > 10 THEN 1.15
-              WHEN AVG(o.quantity) < 2 THEN 0.95
-              ELSE 1
-            END, 2
-          ) AS DECIMAL(15,3)
-        ) - CAST(SUM(o.price * o.quantity) AS DECIMAL(15,3)) DESC
-      LIMIT 10
-    `);
-
-    res.json({ pricePoints, elasticity, recommendations });
-  } catch (error) {
-    console.error('Error fetching price analysis:', error);
-    res.status(500).json({ error: 'Failed to fetch price analysis' });
-  }
-});
-
-// Get category performance data
-router.get('/categories', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    // Common CTE for category paths
-    const categoryPathCTE = `
-      WITH RECURSIVE category_path AS (
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          c.name::text as path
-        FROM categories c
-        WHERE c.parent_id IS NULL
-        
-        UNION ALL
-        
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          (cp.path || ' > ' || c.name)::text
-        FROM categories c
-        JOIN category_path cp ON c.parent_id = cp.cat_id
-      )
-    `;
-    
-    // Get category performance metrics with full path
-    const { rows: performance } = await pool.query(`
-      ${categoryPathCTE},
-      monthly_sales AS (
-        SELECT 
-          c.name,
-          cp.path,
-          SUM(CASE 
-            WHEN o.date >= CURRENT_DATE - INTERVAL '30 days' 
-            THEN o.price * o.quantity 
-            ELSE 0 
-          END) as current_month,
-          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 previous_month
-        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 >= CURRENT_DATE - INTERVAL '60 days'
-        GROUP BY c.name, cp.path
-      )
-      SELECT 
-        c.name as category,
-        cp.path as categoryPath,
-        SUM(o.price * o.quantity) as revenue,
-        SUM(o.price * o.quantity - p.cost_price * o.quantity) as profit,
-        ROUND(
-          ((ms.current_month / NULLIF(ms.previous_month, 0)) - 1) * 100,
-          1
-        ) as growth,
-        COUNT(DISTINCT p.pid) as productCount
-      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
-      LEFT JOIN monthly_sales ms ON c.name = ms.name AND cp.path = ms.path
-      WHERE o.date >= CURRENT_DATE - INTERVAL '60 days'
-      GROUP BY c.name, cp.path, ms.current_month, ms.previous_month
-      HAVING SUM(o.price * o.quantity) > 0
-      ORDER BY revenue DESC
-      LIMIT 10
-    `);
-
-    // Get category revenue distribution with full path
-    const { rows: distribution } = await pool.query(`
-      ${categoryPathCTE}
-      SELECT 
-        c.name as category,
-        cp.path as categoryPath,
-        SUM(o.price * o.quantity) as value
-      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 >= CURRENT_DATE - INTERVAL '30 days'
-      GROUP BY c.name, cp.path
-      HAVING SUM(o.price * o.quantity) > 0
-      ORDER BY value DESC
-      LIMIT 6
-    `);
-
-    // Get category sales trends with full path
-    const { rows: trends } = await pool.query(`
-      ${categoryPathCTE}
-      SELECT 
-        c.name as category,
-        cp.path as categoryPath,
-        to_char(o.date, 'Mon YYYY') as month,
-        SUM(o.price * o.quantity) as sales
-      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 >= CURRENT_DATE - INTERVAL '6 months'
-      GROUP BY 
-        c.name,
-        cp.path,
-        to_char(o.date, 'Mon YYYY'),
-        to_char(o.date, 'YYYY-MM')
-      ORDER BY 
-        c.name,
-        to_char(o.date, 'YYYY-MM')
-    `);
-
-    res.json({ performance, distribution, trends });
-  } catch (error) {
-    console.error('Error fetching category performance:', error);
-    res.status(500).json({ error: 'Failed to fetch category performance' });
-  }
-});
-
-// Forecast endpoint
-router.get('/forecast', async (req, res) => {
-  try {
-    const { brand, startDate, endDate } = req.query;
-    const pool = req.app.locals.pool;
-
-    const [results] = 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
-        FROM categories c
-        WHERE c.parent_id IS NULL
-        
-        UNION ALL
-        
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          CONCAT(cp.path, ' > ', c.name)
-        FROM categories c
-        JOIN category_path cp ON c.parent_id = cp.cat_id
-      ),
-      category_metrics AS (
-        SELECT 
-          c.cat_id,
-          c.name as category_name,
-          cp.path,
-          p.brand,
-          COUNT(DISTINCT p.pid) as num_products,
-          CAST(COALESCE(ROUND(SUM(o.quantity) / DATEDIFF(?, ?), 2), 0) AS DECIMAL(15,3)) as avg_daily_sales,
-          COALESCE(SUM(o.quantity), 0) as total_sold,
-          CAST(COALESCE(ROUND(SUM(o.quantity) / COUNT(DISTINCT p.pid), 2), 0) AS DECIMAL(15,3)) as avgTotalSold,
-          CAST(COALESCE(ROUND(AVG(o.price), 2), 0) AS DECIMAL(15,3)) as avg_price
-        FROM categories c
-        JOIN product_categories pc ON c.cat_id = pc.cat_id
-        JOIN products p ON pc.pid = p.pid
-        JOIN category_path cp ON c.cat_id = cp.cat_id
-        LEFT JOIN product_metrics pmet ON p.pid = pmet.pid
-        LEFT JOIN orders o ON p.pid = o.pid 
-          AND o.date BETWEEN ? AND ?
-          AND o.canceled = false
-        WHERE p.brand = ?
-          AND pmet.first_received_date BETWEEN ? AND ?
-        GROUP BY c.cat_id, c.name, cp.path, p.brand
-      ),
-      product_details AS (
-        SELECT 
-          p.pid,
-          p.title,
-          p.SKU,
-          p.stock_quantity,
-          pc.cat_id,
-          pmet.first_received_date,
-          COALESCE(SUM(o.quantity), 0) as total_sold,
-          CAST(COALESCE(ROUND(AVG(o.price), 2), 0) AS DECIMAL(15,3)) as avg_price
-        FROM products p
-        JOIN product_categories pc ON p.pid = pc.pid
-        JOIN product_metrics pmet ON p.pid = pmet.pid
-        LEFT JOIN orders o ON p.pid = o.pid 
-          AND o.date BETWEEN ? AND ?
-          AND o.canceled = false
-        WHERE p.brand = ?
-          AND pmet.first_received_date BETWEEN ? AND ?
-        GROUP BY p.pid, p.title, p.SKU, p.stock_quantity, pc.cat_id, pmet.first_received_date
-      )
-      SELECT 
-        cm.*,
-        JSON_ARRAYAGG(
-          JSON_OBJECT(
-            'pid', pd.pid,
-            'title', pd.title,
-            'SKU', pd.SKU,
-            'stock_quantity', pd.stock_quantity,
-            'total_sold', pd.total_sold,
-            'avg_price', pd.avg_price,
-            'first_received_date', DATE_FORMAT(pd.first_received_date, '%Y-%m-%d')
-          )
-        ) as products
-      FROM category_metrics cm
-      JOIN product_details pd ON cm.cat_id = pd.cat_id
-      GROUP BY cm.cat_id, cm.category_name, cm.path, cm.brand, cm.num_products, cm.avg_daily_sales, cm.total_sold, cm.avgTotalSold, cm.avg_price
-      ORDER BY cm.total_sold DESC
-    `, [endDate, startDate, startDate, endDate, brand, startDate, endDate, startDate, endDate, brand, startDate, endDate]);
-
-    res.json(results);
-  } catch (error) {
-    console.error('Error fetching forecast data:', error);
-    res.status(500).json({ error: 'Failed to fetch forecast data' });
-  }
-});
-
-module.exports = router; 
+ 

inventory-server/src/routes/brandsAggregate.js

@@ -0,0 +1 @@
+ 

inventory-server/src/routes/categories.js

@@ -1,100 +0,0 @@
-const express = require('express');
-const router = express.Router();
-
-// Get all categories
-router.get('/', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    // Get all categories with metrics and hierarchy info
-    const { rows: categories } = await pool.query(`
-      SELECT 
-        c.cat_id,
-        c.name,
-        c.type,
-        c.parent_id,
-        c.description,
-        c.status,
-        p.name as parent_name,
-        p.type as parent_type,
-        COALESCE(cm.product_count, 0) as product_count,
-        COALESCE(cm.active_products, 0) as active_products,
-        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
-      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
-      ORDER BY 
-        CASE 
-          WHEN c.type = 10 THEN 1  -- sections first
-          WHEN c.type = 11 THEN 2  -- categories second
-          WHEN c.type = 12 THEN 3  -- subcategories third
-          WHEN c.type = 13 THEN 4  -- subsubcategories fourth
-          WHEN c.type = 20 THEN 5  -- themes fifth
-          WHEN c.type = 21 THEN 6  -- subthemes last
-          ELSE 7
-        END,
-        c.name ASC
-    `);
-
-    // Get overall stats
-    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,
-        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 { rows: typeCounts } = await pool.query(`
-      SELECT 
-        type,
-        COUNT(*)::integer as count
-      FROM categories
-      GROUP BY type
-      ORDER BY type
-    `);
-
-    res.json({
-      categories: categories.map(cat => ({
-        cat_id: cat.cat_id,
-        name: cat.name,
-        type: cat.type,
-        parent_id: cat.parent_id,
-        parent_name: cat.parent_name,
-        parent_type: cat.parent_type,
-        description: cat.description,
-        status: cat.status,
-        metrics: {
-          product_count: parseInt(cat.product_count),
-          active_products: parseInt(cat.active_products),
-          total_value: parseFloat(cat.total_value),
-          avg_margin: parseFloat(cat.avg_margin),
-          turnover_rate: parseFloat(cat.turnover_rate),
-          growth_rate: parseFloat(cat.growth_rate)
-        }
-      })),
-      typeCounts: typeCounts.map(tc => ({
-        type: tc.type,
-        count: tc.count // Already cast to integer in the query
-      })),
-      stats: {
-        totalCategories: parseInt(stats.totalcategories),
-        activeCategories: parseInt(stats.activecategories),
-        totalValue: parseFloat(stats.totalvalue),
-        avgMargin: parseFloat(stats.avgmargin),
-        avgGrowth: parseFloat(stats.avggrowth)
-      }
-    });
-  } catch (error) {
-    console.error('Error fetching categories:', error);
-    res.status(500).json({ error: 'Failed to fetch categories' });
-  }
-});
-
-module.exports = router; 

inventory-server/src/routes/config.js

@@ -1,172 +0,0 @@
-const express = require('express');
-const router = express.Router();
-
-// Debug middleware
-router.use((req, res, next) => {
-  console.log(`[Config Route] ${req.method} ${req.path}`);
-  next();
-});
-
-// Get all configuration values
-router.get('/', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    console.log('[Config Route] Fetching configuration values...');
-    
-    const { rows: stockThresholds } = await pool.query('SELECT * FROM stock_thresholds WHERE id = 1');
-    console.log('[Config Route] Stock thresholds:', stockThresholds);
-    
-    const { rows: leadTimeThresholds } = await pool.query('SELECT * FROM lead_time_thresholds WHERE id = 1');
-    console.log('[Config Route] Lead time thresholds:', leadTimeThresholds);
-    
-    const { rows: salesVelocityConfig } = await pool.query('SELECT * FROM sales_velocity_config WHERE id = 1');
-    console.log('[Config Route] Sales velocity config:', salesVelocityConfig);
-    
-    const { rows: abcConfig } = await pool.query('SELECT * FROM abc_classification_config WHERE id = 1');
-    console.log('[Config Route] ABC config:', abcConfig);
-    
-    const { rows: safetyStockConfig } = await pool.query('SELECT * FROM safety_stock_config WHERE id = 1');
-    console.log('[Config Route] Safety stock config:', safetyStockConfig);
-    
-    const { rows: turnoverConfig } = await pool.query('SELECT * FROM turnover_config WHERE id = 1');
-    console.log('[Config Route] Turnover config:', turnoverConfig);
-
-    const response = {
-      stockThresholds: stockThresholds[0],
-      leadTimeThresholds: leadTimeThresholds[0],
-      salesVelocityConfig: salesVelocityConfig[0],
-      abcConfig: abcConfig[0],
-      safetyStockConfig: safetyStockConfig[0],
-      turnoverConfig: turnoverConfig[0]
-    };
-    
-    console.log('[Config Route] Sending response:', response);
-    res.json(response);
-  } catch (error) {
-    console.error('[Config Route] Error fetching configuration:', error);
-    res.status(500).json({ error: 'Failed to fetch configuration', details: error.message });
-  }
-});
-
-// Update stock thresholds
-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 { rows } = await pool.query(
-      `UPDATE stock_thresholds 
-       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 });
-  } catch (error) {
-    console.error('[Config Route] Error updating stock thresholds:', error);
-    res.status(500).json({ error: 'Failed to update stock thresholds' });
-  }
-});
-
-// Update lead time thresholds
-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 { rows } = await pool.query(
-      `UPDATE lead_time_thresholds 
-       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 });
-  } catch (error) {
-    console.error('[Config Route] Error updating lead time thresholds:', error);
-    res.status(500).json({ error: 'Failed to update lead time thresholds' });
-  }
-});
-
-// Update sales velocity config
-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 { rows } = await pool.query(
-      `UPDATE sales_velocity_config 
-       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 });
-  } catch (error) {
-    console.error('[Config Route] Error updating sales velocity config:', error);
-    res.status(500).json({ error: 'Failed to update sales velocity config' });
-  }
-});
-
-// Update ABC classification config
-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 { rows } = await pool.query(
-      `UPDATE abc_classification_config 
-       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 });
-  } catch (error) {
-    console.error('[Config Route] Error updating ABC classification config:', error);
-    res.status(500).json({ error: 'Failed to update ABC classification config' });
-  }
-});
-
-// Update safety stock config
-router.put('/safety-stock/:id', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    const { coverage_days, service_level } = req.body;
-    const { rows } = await pool.query(
-      `UPDATE safety_stock_config 
-       SET coverage_days = $1,
-           service_level = $2
-       WHERE id = $3`,
-      [coverage_days, service_level, req.params.id]
-    );
-    res.json({ success: true });
-  } catch (error) {
-    console.error('[Config Route] Error updating safety stock config:', error);
-    res.status(500).json({ error: 'Failed to update safety stock config' });
-  }
-});
-
-// Update turnover config
-router.put('/turnover/:id', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    const { calculation_period_days, target_rate } = req.body;
-    const { rows } = await pool.query(
-      `UPDATE turnover_config 
-       SET calculation_period_days = $1,
-           target_rate = $2
-       WHERE id = $3`,
-      [calculation_period_days, target_rate, req.params.id]
-    );
-    res.json({ success: true });
-  } catch (error) {
-    console.error('[Config Route] Error updating turnover config:', error);
-    res.status(500).json({ error: 'Failed to update turnover config' });
-  }
-});
-
-// Export the router
-module.exports = router; 

inventory-server/src/routes/csv.js

@@ -1,833 +0,0 @@
-const express = require('express');
-const router = express.Router();
-const { spawn } = require('child_process');
-const path = require('path');
-const db = require('../utils/db');
-
-// Debug middleware MUST be first
-router.use((req, res, next) => {
-    console.log(`[CSV Route Debug] ${req.method} ${req.path}`);
-    next();
-});
-
-// Store active processes and their progress
-let activeImport = null;
-let importProgress = null;
-let activeFullUpdate = null;
-let activeFullReset = null;
-
-// SSE clients for progress updates
-const updateClients = new Set();
-const importClients = new Set();
-const resetClients = new Set();
-const resetMetricsClients = new Set();
-const calculateMetricsClients = new Set();
-const fullUpdateClients = new Set();
-const fullResetClients = new Set();
-
-// Helper to send progress to specific clients
-function sendProgressToClients(clients, data) {
-    // If data is a string, send it directly
-    // If it's an object, convert it to JSON
-    const message = typeof data === 'string' 
-        ? `data: ${data}\n\n`
-        : `data: ${JSON.stringify(data)}\n\n`;
-    
-    clients.forEach(client => {
-        try {
-            client.write(message);
-            // Immediately flush the response
-            if (typeof client.flush === 'function') {
-                client.flush();
-            }
-        } catch (error) {
-            // Silently remove failed client
-            clients.delete(client);
-        }
-    });
-}
-
-// Helper to run a script and stream progress
-function runScript(scriptPath, type, clients) {
-    return new Promise((resolve, reject) => {
-        // Kill any existing process of this type
-        let activeProcess;
-        switch (type) {
-            case 'update':
-                if (activeFullUpdate) {
-                    try { activeFullUpdate.kill(); } catch (e) { }
-                }
-                activeProcess = activeFullUpdate;
-                break;
-            case 'reset':
-                if (activeFullReset) {
-                    try { activeFullReset.kill(); } catch (e) { }
-                }
-                activeProcess = activeFullReset;
-                break;
-        }
-
-        const child = spawn('node', [scriptPath], {
-            stdio: ['inherit', 'pipe', 'pipe']
-        });
-
-        switch (type) {
-            case 'update':
-                activeFullUpdate = child;
-                break;
-            case 'reset':
-                activeFullReset = child;
-                break;
-        }
-
-        let output = '';
-
-        child.stdout.on('data', (data) => {
-            const text = data.toString();
-            output += text;
-            
-            // Split by lines to handle multiple JSON outputs
-            const lines = text.split('\n');
-            lines.filter(line => line.trim()).forEach(line => {
-                try {
-                    // Try to parse as JSON but don't let it affect the display
-                    const jsonData = JSON.parse(line);
-                    // Only end the process if we get a final status
-                    if (jsonData.status === 'complete' || jsonData.status === 'error' || jsonData.status === 'cancelled') {
-                        if (jsonData.status === 'complete' && !jsonData.operation?.includes('complete')) {
-                            // Don't close for intermediate completion messages
-                            sendProgressToClients(clients, line);
-                            return;
-                        }
-                        // Close only on final completion/error/cancellation
-                        switch (type) {
-                            case 'update':
-                                activeFullUpdate = null;
-                                break;
-                            case 'reset':
-                                activeFullReset = null;
-                                break;
-                        }
-                        if (jsonData.status === 'error') {
-                            reject(new Error(jsonData.error || 'Unknown error'));
-                        } else {
-                            resolve({ output });
-                        }
-                    }
-                } catch (e) {
-                    // Not JSON, just display as is
-                }
-                // Always send the raw line
-                sendProgressToClients(clients, line);
-            });
-        });
-
-        child.stderr.on('data', (data) => {
-            const text = data.toString();
-            console.error(text);
-            // Send stderr output directly too
-            sendProgressToClients(clients, text);
-        });
-
-        child.on('close', (code) => {
-            switch (type) {
-                case 'update':
-                    activeFullUpdate = null;
-                    break;
-                case 'reset':
-                    activeFullReset = null;
-                    break;
-            }
-
-            if (code !== 0) {
-                const error = `Script ${scriptPath} exited with code ${code}`;
-                sendProgressToClients(clients, error);
-                reject(new Error(error));
-            }
-            // Don't resolve here - let the completion message from the script trigger the resolve
-        });
-
-        child.on('error', (err) => {
-            switch (type) {
-                case 'update':
-                    activeFullUpdate = null;
-                    break;
-                case 'reset':
-                    activeFullReset = null;
-                    break;
-            }
-            sendProgressToClients(clients, err.message);
-            reject(err);
-        });
-    });
-}
-
-// Progress endpoints
-router.get('/:type/progress', (req, res) => {
-    const { type } = req.params;
-    if (!['update', 'reset'].includes(type)) {
-        return res.status(400).json({ error: 'Invalid operation type' });
-    }
-
-    res.writeHead(200, {
-        'Content-Type': 'text/event-stream',
-        'Cache-Control': 'no-cache',
-        'Connection': 'keep-alive',
-        'Access-Control-Allow-Origin': req.headers.origin || '*',
-        'Access-Control-Allow-Credentials': 'true'
-    });
-
-    // Add this client to the correct set
-    const clients = type === 'update' ? fullUpdateClients : fullResetClients;
-    clients.add(res);
-
-    // Send initial connection message
-    sendProgressToClients(new Set([res]), JSON.stringify({
-        status: 'running',
-        operation: 'Initializing connection...'
-    }));
-
-    // Handle client disconnect
-    req.on('close', () => {
-        clients.delete(res);
-    });
-});
-
-// Debug endpoint to verify route registration
-router.get('/test', (req, res) => {
-    console.log('CSV test endpoint hit');
-    res.json({ message: 'CSV routes are working' });
-});
-
-// Route to check import status
-router.get('/status', (req, res) => {
-    console.log('CSV status endpoint hit');
-    res.json({
-        active: !!activeImport,
-        progress: importProgress
-    });
-});
-
-// Add calculate-metrics status endpoint
-router.get('/calculate-metrics/status', (req, res) => {
-    const calculateMetrics = require('../../scripts/calculate-metrics');
-    const progress = calculateMetrics.getProgress();
-    
-    // Only consider it active if both the process is running and we have progress
-    const isActive = !!activeImport && !!progress;
-    
-    res.json({
-        active: isActive,
-        progress: isActive ? progress : null
-    });
-});
-
-// Route to update CSV files
-router.post('/update', async (req, res, next) => {
-    if (activeImport) {
-        return res.status(409).json({ error: 'Import already in progress' });
-    }
-
-    try {
-        const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'update-csv.js');
-        
-        if (!require('fs').existsSync(scriptPath)) {
-            return res.status(500).json({ error: 'Update script not found' });
-        }
-        
-        activeImport = spawn('node', [scriptPath]);
-        
-        activeImport.stdout.on('data', (data) => {
-            const output = data.toString().trim();
-            
-            try {
-                // Try to parse as JSON
-                const jsonData = JSON.parse(output);
-                sendProgressToClients(updateClients, {
-                    status: 'running',
-                    ...jsonData
-                });
-            } catch (e) {
-                // If not JSON, send as plain progress
-                sendProgressToClients(updateClients, { 
-                    status: 'running',
-                    progress: output
-                });
-            }
-        });
-
-        activeImport.stderr.on('data', (data) => {
-            const error = data.toString().trim();
-            try {
-                // Try to parse as JSON
-                const jsonData = JSON.parse(error);
-                sendProgressToClients(updateClients, { 
-                    status: 'error',
-                    ...jsonData
-                });
-            } catch {
-                sendProgressToClients(updateClients, { 
-                    status: 'error',
-                    error
-                });
-            }
-        });
-
-        await new Promise((resolve, reject) => {
-            activeImport.on('close', (code) => {
-                // Don't treat cancellation (code 143/SIGTERM) as an error
-                if (code === 0 || code === 143) {
-                    sendProgressToClients(updateClients, { 
-                        status: 'complete',
-                        operation: code === 143 ? 'Operation cancelled' : 'Update complete'
-                    });
-                    resolve();
-                } else {
-                    const errorMsg = `Update process exited with code ${code}`;
-                    sendProgressToClients(updateClients, { 
-                        status: 'error',
-                        error: errorMsg
-                    });
-                    reject(new Error(errorMsg));
-                }
-                activeImport = null;
-                importProgress = null;
-            });
-        });
-
-        res.json({ success: true });
-    } catch (error) {
-        console.error('Error updating CSV files:', error);
-        activeImport = null;
-        importProgress = null;
-        sendProgressToClients(updateClients, { 
-            status: 'error',
-            error: error.message
-        });
-        next(error);
-    }
-});
-
-// Route to import CSV files
-router.post('/import', async (req, res) => {
-    if (activeImport) {
-        return res.status(409).json({ error: 'Import already in progress' });
-    }
-
-    try {
-        const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'import-csv.js');
-        
-        if (!require('fs').existsSync(scriptPath)) {
-            return res.status(500).json({ error: 'Import script not found' });
-        }
-        
-        // Get test limits from request body
-        const { products = 0, orders = 10000, purchaseOrders = 10000 } = req.body;
-        
-        // Create environment variables for the script
-        const env = {
-            ...process.env,
-            PRODUCTS_TEST_LIMIT: products.toString(),
-            ORDERS_TEST_LIMIT: orders.toString(),
-            PURCHASE_ORDERS_TEST_LIMIT: purchaseOrders.toString()
-        };
-        
-        activeImport = spawn('node', [scriptPath], { env });
-        
-        activeImport.stdout.on('data', (data) => {
-            const output = data.toString().trim();
-            
-            try {
-                // Try to parse as JSON
-                const jsonData = JSON.parse(output);
-                sendProgressToClients(importClients, {
-                    status: 'running',
-                    ...jsonData
-                });
-            } catch {
-                // If not JSON, send as plain progress
-                sendProgressToClients(importClients, { 
-                    status: 'running',
-                    progress: output
-                });
-            }
-        });
-
-        activeImport.stderr.on('data', (data) => {
-            const error = data.toString().trim();
-            try {
-                // Try to parse as JSON
-                const jsonData = JSON.parse(error);
-                sendProgressToClients(importClients, { 
-                    status: 'error',
-                    ...jsonData
-                });
-            } catch {
-                sendProgressToClients(importClients, { 
-                    status: 'error',
-                    error
-                });
-            }
-        });
-
-        await new Promise((resolve, reject) => {
-            activeImport.on('close', (code) => {
-                // Don't treat cancellation (code 143/SIGTERM) as an error
-                if (code === 0 || code === 143) {
-                    sendProgressToClients(importClients, { 
-                        status: 'complete',
-                        operation: code === 143 ? 'Operation cancelled' : 'Import complete'
-                    });
-                    resolve();
-                } else {
-                    sendProgressToClients(importClients, { 
-                        status: 'error',
-                        error: `Process exited with code ${code}`
-                    });
-                    reject(new Error(`Import process exited with code ${code}`));
-                }
-                activeImport = null;
-                importProgress = null;
-            });
-        });
-
-        res.json({ success: true });
-    } catch (error) {
-        console.error('Error importing CSV files:', error);
-        activeImport = null;
-        importProgress = null;
-        sendProgressToClients(importClients, { 
-            status: 'error',
-            error: error.message
-        });
-        res.status(500).json({ error: 'Failed to import CSV files', details: error.message });
-    }
-});
-
-// Route to cancel active process
-router.post('/cancel', (req, res) => {
-    let killed = false;
-
-    // Get the operation type from the request
-    const { type } = req.query;
-    const clients = type === 'update' ? fullUpdateClients : fullResetClients;
-    const activeProcess = type === 'update' ? activeFullUpdate : activeFullReset;
-
-    if (activeProcess) {
-        try {
-            activeProcess.kill('SIGTERM');
-            if (type === 'update') {
-                activeFullUpdate = null;
-            } else {
-                activeFullReset = null;
-            }
-            killed = true;
-            sendProgressToClients(clients, JSON.stringify({
-                status: 'cancelled',
-                operation: 'Operation cancelled'
-            }));
-        } catch (err) {
-            console.error(`Error killing ${type} process:`, err);
-        }
-    }
-
-    if (killed) {
-        res.json({ success: true });
-    } else {
-        res.status(404).json({ error: 'No active process to cancel' });
-    }
-});
-
-// Route to reset database
-router.post('/reset', async (req, res) => {
-    if (activeImport) {
-        return res.status(409).json({ error: 'Import already in progress' });
-    }
-
-    try {
-        const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'reset-db.js');
-        
-        if (!require('fs').existsSync(scriptPath)) {
-            return res.status(500).json({ error: 'Reset script not found' });
-        }
-        
-        activeImport = spawn('node', [scriptPath]);
-        
-        activeImport.stdout.on('data', (data) => {
-            const output = data.toString().trim();
-            
-            try {
-                // Try to parse as JSON
-                const jsonData = JSON.parse(output);
-                sendProgressToClients(resetClients, {
-                    status: 'running',
-                    ...jsonData
-                });
-            } catch (e) {
-                // If not JSON, send as plain progress
-                sendProgressToClients(resetClients, { 
-                    status: 'running',
-                    progress: output
-                });
-            }
-        });
-
-        activeImport.stderr.on('data', (data) => {
-            const error = data.toString().trim();
-            try {
-                // Try to parse as JSON
-                const jsonData = JSON.parse(error);
-                sendProgressToClients(resetClients, { 
-                    status: 'error',
-                    ...jsonData
-                });
-            } catch {
-                sendProgressToClients(resetClients, { 
-                    status: 'error',
-                    error
-                });
-            }
-        });
-
-        await new Promise((resolve, reject) => {
-            activeImport.on('close', (code) => {
-                // Don't treat cancellation (code 143/SIGTERM) as an error
-                if (code === 0 || code === 143) {
-                    sendProgressToClients(resetClients, { 
-                        status: 'complete',
-                        operation: code === 143 ? 'Operation cancelled' : 'Reset complete'
-                    });
-                    resolve();
-                } else {
-                    const errorMsg = `Reset process exited with code ${code}`;
-                    sendProgressToClients(resetClients, { 
-                        status: 'error',
-                        error: errorMsg
-                    });
-                    reject(new Error(errorMsg));
-                }
-                activeImport = null;
-                importProgress = null;
-            });
-        });
-
-        res.json({ success: true });
-    } catch (error) {
-        console.error('Error resetting database:', error);
-        activeImport = null;
-        importProgress = null;
-        sendProgressToClients(resetClients, { 
-            status: 'error',
-            error: error.message
-        });
-        res.status(500).json({ error: 'Failed to reset database', details: error.message });
-    }
-});
-
-// Add reset-metrics endpoint
-router.post('/reset-metrics', async (req, res) => {
-    if (activeImport) {
-        res.status(400).json({ error: 'Operation already in progress' });
-        return;
-    }
-
-    try {
-        // Set active import to prevent concurrent operations
-        activeImport = {
-            type: 'reset-metrics',
-            status: 'running',
-            operation: 'Starting metrics reset'
-        };
-
-        // Send initial response
-        res.status(200).json({ message: 'Reset metrics started' });
-
-        // Send initial progress through SSE
-        sendProgressToClients(resetMetricsClients, {
-            status: 'running',
-            operation: 'Starting metrics reset'
-        });
-
-        // Run the reset metrics script
-        const resetMetrics = require('../../scripts/reset-metrics');
-        await resetMetrics();
-
-        // Send completion through SSE
-        sendProgressToClients(resetMetricsClients, {
-            status: 'complete',
-            operation: 'Metrics reset completed'
-        });
-
-        activeImport = null;
-    } catch (error) {
-        console.error('Error during metrics reset:', error);
-        
-        // Send error through SSE
-        sendProgressToClients(resetMetricsClients, {
-            status: 'error',
-            error: error.message || 'Failed to reset metrics'
-        });
-        
-        activeImport = null;
-        res.status(500).json({ error: error.message || 'Failed to reset metrics' });
-    }
-});
-
-// Add calculate-metrics endpoint
-router.post('/calculate-metrics', async (req, res) => {
-    if (activeImport) {
-        return res.status(409).json({ error: 'Import already in progress' });
-    }
-
-    try {
-        const scriptPath = path.join(__dirname, '..', '..', 'scripts', 'calculate-metrics.js');
-        
-        if (!require('fs').existsSync(scriptPath)) {
-            return res.status(500).json({ error: 'Calculate metrics script not found' });
-        }
-        
-        activeImport = spawn('node', [scriptPath]);
-        let wasCancelled = false;
-        
-        activeImport.stdout.on('data', (data) => {
-            const output = data.toString().trim();
-            
-            try {
-                // Try to parse as JSON
-                const jsonData = JSON.parse(output);
-                importProgress = {
-                    status: 'running',
-                    ...jsonData.progress
-                };
-                sendProgressToClients(calculateMetricsClients, importProgress);
-            } catch (e) {
-                // If not JSON, send as plain progress
-                importProgress = { 
-                    status: 'running',
-                    progress: output
-                };
-                sendProgressToClients(calculateMetricsClients, importProgress);
-            }
-        });
-
-        activeImport.stderr.on('data', (data) => {
-            if (wasCancelled) return; // Don't send errors if cancelled
-            
-            const error = data.toString().trim();
-            try {
-                // Try to parse as JSON
-                const jsonData = JSON.parse(error);
-                importProgress = { 
-                    status: 'error',
-                    ...jsonData.progress
-                };
-                sendProgressToClients(calculateMetricsClients, importProgress);
-            } catch {
-                importProgress = { 
-                    status: 'error',
-                    error
-                };
-                sendProgressToClients(calculateMetricsClients, importProgress);
-            }
-        });
-
-        await new Promise((resolve, reject) => {
-            activeImport.on('close', (code, signal) => {
-                wasCancelled = signal === 'SIGTERM' || code === 143;
-                activeImport = null;
-                
-                if (code === 0 || wasCancelled) {
-                    if (wasCancelled) {
-                        importProgress = {
-                            status: 'cancelled',
-                            operation: 'Operation cancelled'
-                        };
-                        sendProgressToClients(calculateMetricsClients, importProgress);
-                    } else {
-                        importProgress = {
-                            status: 'complete',
-                            operation: 'Metrics calculation complete'
-                        };
-                        sendProgressToClients(calculateMetricsClients, importProgress);
-                    }
-                    resolve();
-                } else {
-                    importProgress = null;
-                    reject(new Error(`Metrics calculation process exited with code ${code}`));
-                }
-            });
-        });
-
-        res.json({ success: true });
-    } catch (error) {
-        console.error('Error calculating metrics:', error);
-        activeImport = null;
-        importProgress = null;
-        
-        // Only send error if it wasn't a cancellation
-        if (!error.message?.includes('code 143') && !error.message?.includes('SIGTERM')) {
-            sendProgressToClients(calculateMetricsClients, { 
-                status: 'error',
-                error: error.message
-            });
-            res.status(500).json({ error: 'Failed to calculate metrics', details: error.message });
-        } else {
-            res.json({ success: true });
-        }
-    }
-});
-
-// Route to import from production database
-router.post('/import-from-prod', async (req, res) => {
-    if (activeImport) {
-        return res.status(409).json({ error: 'Import already in progress' });
-    }
-
-    try {
-        const importFromProd = require('../../scripts/import-from-prod');
-        
-        // Set up progress handler
-        const progressHandler = (data) => {
-            importProgress = data;
-            sendProgressToClients(importClients, data);
-        };
-
-        // Start the import process
-        importFromProd.outputProgress = progressHandler;
-        activeImport = importFromProd; // Store the module for cancellation
-        
-        // Run the import in the background
-        importFromProd.main().catch(error => {
-            console.error('Error in import process:', error);
-            activeImport = null;
-            importProgress = {
-                status: error.message === 'Import cancelled' ? 'cancelled' : 'error',
-                operation: 'Import process',
-                error: error.message
-            };
-            sendProgressToClients(importClients, importProgress);
-        }).finally(() => {
-            activeImport = null;
-        });
-
-        res.json({ message: 'Import from production started' });
-    } catch (error) {
-        console.error('Error starting production import:', error);
-        activeImport = null;
-        res.status(500).json({ error: error.message || 'Failed to start production import' });
-    }
-});
-
-// POST /csv/full-update - Run full update script
-router.post('/full-update', async (req, res) => {
-    try {
-        const scriptPath = path.join(__dirname, '../../scripts/full-update.js');
-        runScript(scriptPath, 'update', fullUpdateClients)
-            .catch(error => {
-                console.error('Update failed:', error);
-            });
-        res.status(202).json({ message: 'Update started' });
-    } catch (error) {
-        res.status(500).json({ error: error.message });
-    }
-});
-
-// POST /csv/full-reset - Run full reset script
-router.post('/full-reset', async (req, res) => {
-    try {
-        const scriptPath = path.join(__dirname, '../../scripts/full-reset.js');
-        runScript(scriptPath, 'reset', fullResetClients)
-            .catch(error => {
-                console.error('Reset failed:', error);
-            });
-        res.status(202).json({ message: 'Reset started' });
-    } catch (error) {
-        res.status(500).json({ error: error.message });
-    }
-});
-
-// GET /history/import - Get recent import history
-router.get('/history/import', async (req, res) => {
-    try {
-        const pool = req.app.locals.pool;
-        const { rows } = await pool.query(`
-            SELECT 
-                id,
-                start_time,
-                end_time,
-                status,
-                error_message,
-                records_added::integer,
-                records_updated::integer
-            FROM import_history 
-            ORDER BY start_time DESC 
-            LIMIT 20
-        `);
-        res.json(rows || []);
-    } catch (error) {
-        console.error('Error fetching import history:', error);
-        res.status(500).json({ error: error.message });
-    }
-});
-
-// GET /history/calculate - Get recent calculation history
-router.get('/history/calculate', async (req, res) => {
-    try {
-        const pool = req.app.locals.pool;
-        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
-        `);
-        res.json(rows || []);
-    } catch (error) {
-        console.error('Error fetching calculate history:', error);
-        res.status(500).json({ error: error.message });
-    }
-});
-
-// GET /status/modules - Get module calculation status
-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::timestamp 
-            FROM calculate_status 
-            ORDER BY module_name
-        `);
-        res.json(rows || []);
-    } catch (error) {
-        console.error('Error fetching module status:', error);
-        res.status(500).json({ error: error.message });
-    }
-});
-
-// GET /status/tables - Get table sync status
-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::timestamp 
-            FROM sync_status 
-            ORDER BY table_name
-        `);
-        res.json(rows || []);
-    } catch (error) {
-        console.error('Error fetching table status:', error);
-        res.status(500).json({ error: error.message });
-    }
-});
-
-module.exports = router; 

inventory-server/src/routes/import.js

@@ -5,10 +5,14 @@ const mysql = require('mysql2/promise');
 const multer = require('multer');
 const path = require('path');
 const fs = require('fs');
+const fsp = fs.promises;
+const sharp = require('sharp');
 
 // Create uploads directory if it doesn't exist
 const uploadsDir = path.join('/var/www/html/inventory/uploads/products');
+const reusableUploadsDir = path.join('/var/www/html/inventory/uploads/reusable');
 fs.mkdirSync(uploadsDir, { recursive: true });
+fs.mkdirSync(reusableUploadsDir, { recursive: true });
 
 // Create a Map to track image upload times and their scheduled deletion
 const imageUploadMap = new Map();
@@ -33,8 +37,17 @@ const connectionCache = {
   }
 };
 
+const MIN_IMAGE_DIMENSION = 1000;
+const MAX_IMAGE_SIZE_BYTES = 5 * 1024 * 1024;
+
 // Function to schedule image deletion after 24 hours
 const scheduleImageDeletion = (filename, filePath) => {
+  // Only schedule deletion for images in the products folder
+  if (!filePath.includes('/uploads/products/')) {
+    console.log(`Skipping deletion for non-product image: ${filename}`);
+    return;
+  }
+
   // Delete any existing timeout for this file
   if (imageUploadMap.has(filename)) {
     clearTimeout(imageUploadMap.get(filename).timeoutId);
@@ -137,6 +150,255 @@ const cleanupImagesOnStartup = () => {
 // Run cleanup on server start
 cleanupImagesOnStartup();
 
+const bytesToMegabytes = (bytes) => Number((bytes / (1024 * 1024)).toFixed(2));
+
+const processUploadedImage = async (filePath, mimetype) => {
+  const notices = [];
+  const legacyWarnings = [];
+  const metadata = {};
+
+  const originalBuffer = await fsp.readFile(filePath);
+  let baseMetadata = await sharp(originalBuffer, { failOn: 'none' }).metadata();
+
+  metadata.width = baseMetadata.width || 0;
+  metadata.height = baseMetadata.height || 0;
+  metadata.size = originalBuffer.length;
+  metadata.colorSpace = baseMetadata.space || baseMetadata.colourspace || null;
+
+  if (
+    baseMetadata.width &&
+    baseMetadata.height &&
+    (baseMetadata.width < MIN_IMAGE_DIMENSION || baseMetadata.height < MIN_IMAGE_DIMENSION)
+  ) {
+    const message = `Image is ${baseMetadata.width}x${baseMetadata.height}. Recommended minimum is ${MIN_IMAGE_DIMENSION}x${MIN_IMAGE_DIMENSION}.`;
+    notices.push({
+      message,
+      level: 'warning',
+      code: 'dimensions_too_small',
+      source: 'server'
+    });
+    legacyWarnings.push(message);
+  }
+
+  const colorSpace = (baseMetadata.space || baseMetadata.colourspace || '').toLowerCase();
+  let shouldConvertToRgb = colorSpace === 'cmyk';
+
+  if (shouldConvertToRgb) {
+    const message = 'Converted image from CMYK to RGB.';
+    notices.push({
+      message,
+      level: 'info',
+      code: 'converted_to_rgb',
+      source: 'server'
+    });
+    legacyWarnings.push(message);
+  }
+
+  const format = (baseMetadata.format || '').toLowerCase();
+  if (format === 'gif') {
+    if (metadata.size > MAX_IMAGE_SIZE_BYTES) {
+      const message = `GIF optimization is limited; resulting size is ${bytesToMegabytes(metadata.size)}MB (target 5MB).`;
+      notices.push({
+        message,
+        level: 'warning',
+        code: 'gif_size_limit',
+        source: 'server'
+      });
+      legacyWarnings.push(message);
+    }
+    metadata.convertedToRgb = false;
+    metadata.resized = false;
+    return { notices, warnings: legacyWarnings, metadata, finalSize: metadata.size };
+  }
+
+  const supportsQuality = ['jpeg', 'jpg', 'webp'].includes(format);
+  let targetQuality = supportsQuality ? 90 : undefined;
+  let finalQuality = undefined;
+
+  let currentWidth = baseMetadata.width || null;
+  let currentHeight = baseMetadata.height || null;
+
+  let resized = false;
+  let mutated = false;
+  let finalBuffer = originalBuffer;
+  let finalInfo = baseMetadata;
+
+  const encode = async ({ width, height, quality }) => {
+    let pipeline = sharp(originalBuffer, { failOn: 'none' });
+
+    if (shouldConvertToRgb) {
+      pipeline = pipeline.toColorspace('srgb');
+    }
+
+    if (width || height) {
+      pipeline = pipeline.resize({
+        width: width ?? undefined,
+        height: height ?? undefined,
+        fit: 'inside',
+        withoutEnlargement: true,
+      });
+    }
+
+    switch (format) {
+      case 'png':
+        pipeline = pipeline.png({
+          compressionLevel: 9,
+          adaptiveFiltering: true,
+          palette: true,
+        });
+        break;
+      case 'webp':
+        pipeline = pipeline.webp({ quality: quality ?? 90 });
+        break;
+      case 'jpeg':
+      case 'jpg':
+      default:
+        pipeline = pipeline.jpeg({ quality: quality ?? 90, mozjpeg: true });
+        break;
+    }
+
+    return pipeline.toBuffer({ resolveWithObject: true });
+  };
+
+  const canResize =
+    (currentWidth && currentWidth > MIN_IMAGE_DIMENSION) ||
+    (currentHeight && currentHeight > MIN_IMAGE_DIMENSION);
+
+  if (metadata.size > MAX_IMAGE_SIZE_BYTES && (supportsQuality || canResize)) {
+    const maxAttempts = 8;
+
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      let targetWidth = currentWidth;
+      let targetHeight = currentHeight;
+      let resizedThisAttempt = false;
+
+      if (currentWidth && currentWidth > MIN_IMAGE_DIMENSION) {
+        targetWidth = Math.max(MIN_IMAGE_DIMENSION, Math.round(currentWidth * 0.85));
+      }
+
+      if (currentHeight && currentHeight > MIN_IMAGE_DIMENSION) {
+        targetHeight = Math.max(MIN_IMAGE_DIMENSION, Math.round(currentHeight * 0.85));
+      }
+
+      if (
+        (targetWidth && currentWidth && targetWidth < currentWidth) ||
+        (targetHeight && currentHeight && targetHeight < currentHeight)
+      ) {
+        resized = true;
+        resizedThisAttempt = true;
+        currentWidth = targetWidth;
+        currentHeight = targetHeight;
+      } else if (!supportsQuality || (targetQuality && targetQuality <= 70)) {
+        // Cannot resize further and quality cannot be adjusted
+        break;
+      }
+
+      const qualityForAttempt = supportsQuality ? targetQuality : undefined;
+      const { data, info } = await encode({
+        width: currentWidth,
+        height: currentHeight,
+        quality: qualityForAttempt,
+      });
+
+      mutated = true;
+      finalBuffer = data;
+      finalInfo = info;
+      metadata.optimizedSize = data.length;
+      if (info.width) metadata.width = info.width;
+      if (info.height) metadata.height = info.height;
+      if (info.width) currentWidth = info.width;
+      if (info.height) currentHeight = info.height;
+
+      if (supportsQuality && qualityForAttempt) {
+        finalQuality = qualityForAttempt;
+      }
+
+      if (data.length <= MAX_IMAGE_SIZE_BYTES) {
+        break;
+      }
+
+      if (resizedThisAttempt) {
+        continue;
+      }
+
+      if (supportsQuality && targetQuality && targetQuality > 70) {
+        const nextQuality = Math.max(70, targetQuality - 10);
+        if (nextQuality === targetQuality) {
+          break;
+        }
+        targetQuality = nextQuality;
+        continue;
+      }
+
+      break;
+    }
+
+    if (finalBuffer.length > MAX_IMAGE_SIZE_BYTES) {
+      const message = `Optimized image remains ${bytesToMegabytes(finalBuffer.length)}MB (target 5MB).`;
+      notices.push({
+        message,
+        level: 'warning',
+        code: 'size_over_limit',
+        source: 'server'
+      });
+      legacyWarnings.push(message);
+    }
+  } else if (shouldConvertToRgb) {
+    const { data, info } = await encode({ width: currentWidth, height: currentHeight });
+    mutated = true;
+    finalBuffer = data;
+    finalInfo = info;
+    metadata.optimizedSize = data.length;
+    if (info.width) metadata.width = info.width;
+    if (info.height) metadata.height = info.height;
+    if (info.width) currentWidth = info.width;
+    if (info.height) currentHeight = info.height;
+  }
+
+  if (mutated) {
+    await fsp.writeFile(filePath, finalBuffer);
+    metadata.optimizedSize = finalBuffer.length;
+  } else {
+    // No transformation occurred; still need to ensure we report original stats
+    metadata.optimizedSize = metadata.size;
+  }
+
+  metadata.convertedToRgb = shouldConvertToRgb && mutated;
+  metadata.resized = resized;
+  if (finalQuality) {
+    metadata.quality = finalQuality;
+  }
+
+  if (resized && metadata.width && metadata.height) {
+    const message = `Image resized to ${metadata.width}x${metadata.height} during optimization.`;
+    notices.push({
+      message,
+      level: 'info',
+      code: 'resized',
+      source: 'server'
+    });
+    legacyWarnings.push(message);
+  }
+
+  if (finalQuality && finalQuality < 90) {
+    const message = `Image quality adjusted to ${finalQuality} to reduce file size.`;
+    notices.push({
+      message,
+      level: 'info',
+      code: 'quality_adjusted',
+      source: 'server'
+    });
+    legacyWarnings.push(message);
+  }
+
+  return {
+    notices,
+    warnings: legacyWarnings,
+    metadata,
+    finalSize: finalBuffer.length,
+  };
+};
+
 // Configure multer for file uploads
 const storage = multer.diskStorage({
   destination: function (req, file, cb) {
@@ -170,7 +432,7 @@ const storage = multer.diskStorage({
 const upload = multer({ 
   storage: storage,
   limits: {
-    fileSize: 5 * 1024 * 1024, // 5MB max file size
+    fileSize: 15 * 1024 * 1024, // Allow bigger uploads; processing will reduce to 5MB
   },
   fileFilter: function (req, file, cb) {
     // Accept only image files
@@ -337,7 +599,7 @@ async function setupSshTunnel() {
 }
 
 // Image upload endpoint
-router.post('/upload-image', upload.single('image'), (req, res) => {
+router.post('/upload-image', upload.single('image'), async (req, res) => {
   try {
     if (!req.file) {
       return res.status(400).json({ error: 'No image file provided' });
@@ -367,9 +629,13 @@ router.post('/upload-image', upload.single('image'), (req, res) => {
       }
     });
 
+    // Process the image (resize/compress/color-space) before responding
+    const processingResult = await processUploadedImage(filePath, req.file.mimetype);
+    req.file.size = processingResult.finalSize;
+
     // Create URL for the uploaded file - using an absolute URL with domain
-    // This will generate a URL like: https://inventory.acot.site/uploads/products/filename.jpg
-    const baseUrl = 'https://inventory.acot.site';
+    // This will generate a URL like: https://tools.acherryontop.com/uploads/products/filename.jpg
+    const baseUrl = 'https://tools.acherryontop.com';
     const imageUrl = `${baseUrl}/uploads/products/${req.file.filename}`;
     
     // Schedule this image for deletion in 24 hours
@@ -382,11 +648,24 @@ router.post('/upload-image', upload.single('image'), (req, res) => {
       fileName: req.file.filename,
       mimetype: req.file.mimetype,
       fullPath: filePath,
+      notices: processingResult.notices,
+      warnings: processingResult.warnings,
+      metadata: processingResult.metadata,
       message: 'Image uploaded successfully (will auto-delete after 24 hours)'
     });
     
   } catch (error) {
     console.error('Error uploading image:', error);
+    if (req?.file?.filename) {
+      const cleanupPath = path.join(uploadsDir, req.file.filename);
+      if (fs.existsSync(cleanupPath)) {
+        try {
+          fs.unlinkSync(cleanupPath);
+        } catch (cleanupError) {
+          console.error('Failed to remove file after processing error:', cleanupError);
+        }
+      }
+    }
     res.status(500).json({ error: error.message || 'Failed to upload image' });
   }
 });
@@ -407,6 +686,14 @@ router.delete('/delete-image', (req, res) => {
       return res.status(404).json({ error: 'File not found' });
     }
     
+    // Only allow deletion of images in the products folder
+    if (!filePath.includes('/uploads/products/')) {
+      return res.status(403).json({ 
+        error: 'Cannot delete images outside the products folder',
+        message: 'This image is in a protected folder and cannot be deleted through this endpoint'
+      });
+    }
+    
     // Delete the file
     fs.unlinkSync(filePath);
     
@@ -428,6 +715,26 @@ router.delete('/delete-image', (req, res) => {
   }
 });
 
+// Clear all taxonomy caches
+router.post('/clear-taxonomy-cache', (req, res) => {
+  try {
+    // Clear all entries from the query cache
+    const cacheSize = connectionCache.queryCache.size;
+    connectionCache.queryCache.clear();
+
+    console.log(`Cleared ${cacheSize} entries from taxonomy cache`);
+
+    res.json({
+      success: true,
+      message: `Cache cleared (${cacheSize} entries removed)`,
+      clearedEntries: cacheSize
+    });
+  } catch (error) {
+    console.error('Error clearing taxonomy cache:', error);
+    res.status(500).json({ error: 'Failed to clear cache' });
+  }
+});
+
 // Get all options for import fields
 router.get('/field-options', async (req, res) => {
     try {
@@ -641,11 +948,19 @@ router.get('/check-file/:filename', (req, res) => {
     return res.status(400).json({ error: 'Invalid filename' });
   }
   
-  const filePath = path.join(uploadsDir, filename);
+  // First check in products directory
+  let filePath = path.join(uploadsDir, filename);
+  let exists = fs.existsSync(filePath);
+  
+  // If not found in products, check in reusable directory
+  if (!exists) {
+    filePath = path.join(reusableUploadsDir, filename);
+    exists = fs.existsSync(filePath);
+  }
   
   try {
     // Check if file exists
-    if (!fs.existsSync(filePath)) {
+    if (!exists) {
       return res.status(404).json({ 
         error: 'File not found', 
         path: filePath,
@@ -685,13 +1000,23 @@ router.get('/check-file/:filename', (req, res) => {
 // List all files in uploads directory
 router.get('/list-uploads', (req, res) => {
   try {
-    if (!fs.existsSync(uploadsDir)) {
-      return res.status(404).json({ error: 'Uploads directory not found', path: uploadsDir });
+    const { directory = 'products' } = req.query;
+    
+    // Determine which directory to list
+    let targetDir;
+    if (directory === 'reusable') {
+      targetDir = reusableUploadsDir;
+    } else {
+      targetDir = uploadsDir; // default to products
     }
     
-    const files = fs.readdirSync(uploadsDir);
+    if (!fs.existsSync(targetDir)) {
+      return res.status(404).json({ error: 'Uploads directory not found', path: targetDir });
+    }
+    
+    const files = fs.readdirSync(targetDir);
     const fileDetails = files.map(file => {
-      const filePath = path.join(uploadsDir, file);
+      const filePath = path.join(targetDir, file);
       try {
         const stats = fs.statSync(filePath);
         return {
@@ -709,12 +1034,13 @@ router.get('/list-uploads', (req, res) => {
     });
     
     return res.json({
-      directory: uploadsDir,
+      directory: targetDir,
+      type: directory,
       count: files.length,
       files: fileDetails
     });
   } catch (error) {
-    return res.status(500).json({ error: error.message, path: uploadsDir });
+    return res.status(500).json({ error: error.message });
   }
 });
 
@@ -920,6 +1246,155 @@ router.get('/search-products', async (req, res) => {
   }
 });
 
+const UPC_SUPPLIER_PREFIX_LEADING_DIGIT = '4';
+const UPC_MAX_SEQUENCE = 99999;
+const UPC_RESERVATION_TTL = 5 * 60 * 1000; // 5 minutes
+
+function buildSupplierPrefix(supplierId) {
+  const numericId = Number.parseInt(String(supplierId), 10);
+  if (Number.isNaN(numericId) || numericId < 0) {
+    return null;
+  }
+
+  const padded = String(numericId).padStart(5, '0');
+  const prefix = `${UPC_SUPPLIER_PREFIX_LEADING_DIGIT}${padded}`;
+  return prefix.length === 6 ? prefix : null;
+}
+
+function calculateUpcCheckDigit(upcWithoutCheckDigit) {
+  if (!/^\d{11}$/.test(upcWithoutCheckDigit)) {
+    throw new Error('UPC body must be 11 numeric characters');
+  }
+
+  let sum = 0;
+  for (let i = 0; i < upcWithoutCheckDigit.length; i += 1) {
+    const digit = Number.parseInt(upcWithoutCheckDigit[i], 10);
+    sum += (i % 2 === 0) ? digit * 3 : digit;
+  }
+
+  const mod = sum % 10;
+  return mod === 0 ? 0 : 10 - mod;
+}
+
+const upcReservationCache = new Map();
+const upcGenerationLocks = new Map();
+
+function getReservedSequence(prefix) {
+  const entry = upcReservationCache.get(prefix);
+  if (!entry) {
+    return 0;
+  }
+
+  if (Date.now() > entry.expiresAt) {
+    upcReservationCache.delete(prefix);
+    return 0;
+  }
+
+  return entry.lastSequence;
+}
+
+function setReservedSequence(prefix, sequence) {
+  upcReservationCache.set(prefix, {
+    lastSequence: sequence,
+    expiresAt: Date.now() + UPC_RESERVATION_TTL
+  });
+}
+
+async function runWithSupplierLock(prefix, task) {
+  const previous = upcGenerationLocks.get(prefix) || Promise.resolve();
+  const chained = previous.catch(() => {}).then(() => task());
+  upcGenerationLocks.set(prefix, chained);
+
+  try {
+    return await chained;
+  } finally {
+    if (upcGenerationLocks.get(prefix) === chained) {
+      upcGenerationLocks.delete(prefix);
+    }
+  }
+}
+
+router.post('/generate-upc', async (req, res) => {
+  const { supplierId, increment } = req.body || {};
+
+  if (supplierId === undefined || supplierId === null || String(supplierId).trim() === '') {
+    return res.status(400).json({ error: 'Supplier ID is required to generate a UPC' });
+  }
+
+  const supplierPrefix = buildSupplierPrefix(supplierId);
+  if (!supplierPrefix) {
+    return res.status(400).json({ error: 'Supplier ID must be a non-negative number with at most 5 digits' });
+  }
+
+  const step = Number.parseInt(increment, 10);
+  const sequenceIncrement = Number.isNaN(step) || step < 1 ? 1 : step;
+
+  try {
+    const result = await runWithSupplierLock(supplierPrefix, async () => {
+      const { connection } = await getDbConnection();
+
+      const [rows] = await connection.query(
+        `SELECT CAST(SUBSTRING(upc,7,5) AS UNSIGNED) AS num
+           FROM products
+          WHERE LEFT(upc, 6) = ? AND LENGTH(upc) = 12
+       ORDER BY num DESC
+          LIMIT 1`,
+        [supplierPrefix]
+      );
+
+      const lastSequenceFromDb = rows && rows.length > 0 && rows[0].num !== null
+        ? Number.parseInt(rows[0].num, 10) || 0
+        : 0;
+
+      const cachedSequence = getReservedSequence(supplierPrefix);
+      const baselineSequence = Math.max(lastSequenceFromDb, cachedSequence);
+
+      let nextSequence = baselineSequence + sequenceIncrement;
+      let candidateUpc = null;
+      let attempts = 0;
+
+      while (attempts < 10 && nextSequence <= UPC_MAX_SEQUENCE) {
+        const sequencePart = String(nextSequence).padStart(5, '0');
+        const upcBody = `${supplierPrefix}${sequencePart}`;
+        const checkDigit = calculateUpcCheckDigit(upcBody);
+        const fullUpc = `${upcBody}${checkDigit}`;
+
+        const [existing] = await connection.query(
+          'SELECT 1 FROM products WHERE upc = ? LIMIT 1',
+          [fullUpc]
+        );
+
+        if (!existing || existing.length === 0) {
+          candidateUpc = { upc: fullUpc, sequence: nextSequence };
+          break;
+        }
+
+        nextSequence += 1;
+        attempts += 1;
+      }
+
+      if (!candidateUpc) {
+        const reason = nextSequence > UPC_MAX_SEQUENCE
+          ? 'UPC range exhausted for this supplier'
+          : 'Unable to find an available UPC';
+        const error = new Error(reason);
+        error.status = 409;
+        throw error;
+      }
+
+      setReservedSequence(supplierPrefix, candidateUpc.sequence);
+      return candidateUpc.upc;
+    });
+
+    return res.json({ success: true, upc: result });
+  } catch (error) {
+    console.error('Error generating UPC:', error);
+    const status = error.status && Number.isInteger(error.status) ? error.status : 500;
+    const message = status === 500 ? 'Failed to generate UPC' : error.message;
+    return res.status(status).json({ error: message, details: status === 500 ? error.message : undefined });
+  }
+});
+
 // Endpoint to check UPC and generate item number
 router.get('/check-upc-and-generate-sku', async (req, res) => {
   const { upc, supplierId } = req.query;
@@ -939,7 +1414,7 @@ router.get('/check-upc-and-generate-sku', async (req, res) => {
     
     if (upcCheck.length > 0) {
       return res.status(409).json({ 
-        error: 'UPC already exists', 
+        error: 'A product with this UPC already exists', 
         existingProductId: upcCheck[0].pid,
         existingItemNumber: upcCheck[0].itemnumber
       });
@@ -1114,4 +1589,4 @@ router.get('/product-categories/:pid', async (req, res) => {
   }
 });
 
-module.exports = router; 
+module.exports = router; 

inventory-server/src/routes/metrics.js

@@ -1,62 +0,0 @@
-const express = require('express');
-const router = express.Router();
-
-// Get key metrics trends (revenue, inventory value, GMROI)
-router.get('/trends', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    const { rows } = await pool.query(`
-      WITH MonthlyMetrics AS (
-        SELECT 
-          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 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) >= 
-          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 
-        to_char(date, 'Mon YY') as date,
-        revenue,
-        inventory_value,
-        gmroi
-      FROM MonthlyMetrics
-    `);
-
-    console.log('Raw metrics trends data:', rows);
-
-    // Transform the data into the format expected by the frontend
-    const transformedData = {
-      revenue: rows.map(row => ({
-        date: row.date,
-        value: parseFloat(row.revenue)
-      })),
-      inventory_value: rows.map(row => ({
-        date: row.date,
-        value: parseFloat(row.inventory_value)
-      })),
-      gmroi: rows.map(row => ({
-        date: row.date,
-        value: parseFloat(row.gmroi)
-      }))
-    };
-
-    console.log('Transformed metrics data:', transformedData);
-    res.json(transformedData);
-  } catch (error) {
-    console.error('Error fetching metrics trends:', error);
-    res.status(500).json({ error: 'Failed to fetch metrics trends' });
-  }
-});
-
-module.exports = router; 

inventory-server/src/routes/orders.js

@@ -1,261 +0,0 @@
-const express = require('express');
-const router = express.Router();
-
-// Get all orders with pagination, filtering, and sorting
-router.get('/', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    const page = parseInt(req.query.page) || 1;
-    const limit = parseInt(req.query.limit) || 50;
-    const offset = (page - 1) * limit;
-    const search = req.query.search || '';
-    const status = req.query.status || 'all';
-    const fromDate = req.query.fromDate ? new Date(req.query.fromDate) : null;
-    const toDate = req.query.toDate ? new Date(req.query.toDate) : null;
-    const minAmount = parseFloat(req.query.minAmount) || 0;
-    const maxAmount = req.query.maxAmount ? parseFloat(req.query.maxAmount) : null;
-    const sortColumn = req.query.sortColumn || 'date';
-    const sortDirection = req.query.sortDirection === 'desc' ? 'DESC' : 'ASC';
-
-    // Build the WHERE clause
-    const conditions = ['o1.canceled = false'];
-    const params = [];
-    let paramCounter = 1;
-
-    if (search) {
-      conditions.push(`(o1.order_number ILIKE $${paramCounter} OR o1.customer ILIKE $${paramCounter})`);
-      params.push(`%${search}%`);
-      paramCounter++;
-    }
-
-    if (status !== 'all') {
-      conditions.push(`o1.status = $${paramCounter}`);
-      params.push(status);
-      paramCounter++;
-    }
-
-    if (fromDate) {
-      conditions.push(`DATE(o1.date) >= DATE($${paramCounter})`);
-      params.push(fromDate.toISOString());
-      paramCounter++;
-    }
-
-    if (toDate) {
-      conditions.push(`DATE(o1.date) <= DATE($${paramCounter})`);
-      params.push(toDate.toISOString());
-      paramCounter++;
-    }
-
-    if (minAmount > 0) {
-      conditions.push(`total_amount >= $${paramCounter}`);
-      params.push(minAmount);
-      paramCounter++;
-    }
-
-    if (maxAmount) {
-      conditions.push(`total_amount <= $${paramCounter}`);
-      params.push(maxAmount);
-      paramCounter++;
-    }
-
-    // Get total count for pagination
-    const { rows: [countResult] } = await pool.query(`
-      SELECT COUNT(DISTINCT o1.order_number) as total 
-      FROM orders o1
-      LEFT JOIN (
-        SELECT order_number, SUM(price * quantity) as total_amount
-        FROM orders
-        GROUP BY order_number
-      ) totals ON o1.order_number = totals.order_number
-      WHERE ${conditions.join(' AND ')}
-    `, params);
-    
-    const total = countResult.total;
-
-    // Get paginated results
-    const query = `
-      SELECT 
-        o1.order_number,
-        o1.customer,
-        o1.date,
-        o1.status,
-        o1.payment_method,
-        o1.shipping_method,
-        COUNT(o2.pid) as items_count,
-        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 ')}
-      GROUP BY 
-        o1.order_number,
-        o1.customer,
-        o1.date,
-        o1.status,
-        o1.payment_method,
-        o1.shipping_method
-      ORDER BY ${
-        sortColumn === 'items_count' || sortColumn === 'total_amount' 
-          ? `${sortColumn} ${sortDirection}`
-          : `o1.${sortColumn} ${sortDirection}`
-      }
-      LIMIT $${paramCounter} OFFSET $${paramCounter + 1}
-    `;
-
-    params.push(limit, offset);
-    const { rows } = await pool.query(query, params);
-
-    // Get order statistics
-    const { rows: [orderStats] } = await pool.query(`
-      WITH CurrentStats AS (
-        SELECT 
-          COUNT(DISTINCT order_number) as total_orders,
-          ROUND(SUM(price * quantity)::numeric, 3) as total_revenue
-        FROM orders
-        WHERE canceled = false
-          AND DATE(date) >= CURRENT_DATE - INTERVAL '30 days'
-      ),
-      PreviousStats AS (
-        SELECT 
-          COUNT(DISTINCT order_number) as prev_orders,
-          ROUND(SUM(price * quantity)::numeric, 3) as prev_revenue
-        FROM orders
-        WHERE canceled = false
-          AND DATE(date) BETWEEN CURRENT_DATE - INTERVAL '60 days' AND CURRENT_DATE - INTERVAL '30 days'
-      ),
-      OrderValues AS (
-        SELECT 
-          order_number,
-          ROUND(SUM(price * quantity)::numeric, 3) as order_value
-        FROM orders
-        WHERE canceled = false
-          AND DATE(date) >= CURRENT_DATE - INTERVAL '30 days'
-        GROUP BY order_number
-      )
-      SELECT 
-        cs.total_orders,
-        cs.total_revenue,
-        CASE 
-          WHEN ps.prev_orders > 0 
-          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 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 ROUND((cs.total_revenue::numeric / cs.total_orders), 3)
-          ELSE 0 
-        END as average_order_value,
-        CASE 
-          WHEN ps.prev_orders > 0 
-          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
-    `);
-    
-    res.json({
-      orders: rows.map(row => ({
-        ...row,
-        total_amount: parseFloat(row.total_amount) || 0,
-        items_count: parseInt(row.items_count) || 0,
-        date: row.date
-      })),
-      pagination: {
-        total,
-        pages: Math.ceil(total / limit),
-        currentPage: page,
-        limit
-      },
-      stats: {
-        totalOrders: parseInt(orderStats.total_orders) || 0,
-        totalRevenue: parseFloat(orderStats.total_revenue) || 0,
-        orderGrowth: parseFloat(orderStats.order_growth) || 0,
-        revenueGrowth: parseFloat(orderStats.revenue_growth) || 0,
-        averageOrderValue: parseFloat(orderStats.average_order_value) || 0,
-        aovGrowth: orderStats.prev_average_order_value > 0 
-          ? ((orderStats.average_order_value - orderStats.prev_average_order_value) / orderStats.prev_average_order_value * 100)
-          : 0,
-        conversionRate: 2.5, // Placeholder - would need actual visitor data
-        conversionGrowth: 0.5 // Placeholder - would need actual visitor data
-      }
-    });
-  } catch (error) {
-    console.error('Error fetching orders:', error);
-    res.status(500).json({ error: 'Failed to fetch orders' });
-  }
-});
-
-// Get a single order with its items
-router.get('/:orderNumber', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    // Get order details
-    const { rows: orderRows } = await pool.query(`
-      SELECT DISTINCT
-        o1.order_number,
-        o1.customer,
-        o1.date,
-        o1.status,
-        o1.payment_method,
-        o1.shipping_method,
-        o1.shipping_address,
-        o1.billing_address,
-        COUNT(o2.pid) as items_count,
-        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 = $1 AND o1.canceled = false
-      GROUP BY 
-        o1.order_number,
-        o1.customer,
-        o1.date,
-        o1.status,
-        o1.payment_method,
-        o1.shipping_method,
-        o1.shipping_address,
-        o1.billing_address
-    `, [req.params.orderNumber]);
-
-    if (orderRows.length === 0) {
-      return res.status(404).json({ error: 'Order not found' });
-    }
-
-    // Get order items
-    const { rows: itemRows } = await pool.query(`
-      SELECT 
-        o.pid,
-        p.title,
-        p.SKU,
-        o.quantity,
-        o.price,
-        ROUND((o.price * o.quantity)::numeric, 3) as total
-      FROM orders o
-      JOIN products p ON o.pid = p.pid
-      WHERE o.order_number = $1 AND o.canceled = false
-    `, [req.params.orderNumber]);
-
-    const order = {
-      ...orderRows[0],
-      total_amount: parseFloat(orderRows[0].total_amount) || 0,
-      items_count: parseInt(orderRows[0].items_count) || 0,
-      items: itemRows.map(item => ({
-        ...item,
-        price: parseFloat(item.price) || 0,
-        total: parseFloat(item.total) || 0,
-        quantity: parseInt(item.quantity) || 0
-      }))
-    };
-
-    res.json(order);
-  } catch (error) {
-    console.error('Error fetching order:', error);
-    res.status(500).json({ error: 'Failed to fetch order' });
-  }
-});
-
-module.exports = router; 

inventory-server/src/routes/products.js

@@ -1,767 +0,0 @@
-const express = require('express');
-const router = express.Router();
-const multer = require('multer');
-const { importProductsFromCSV } = require('../utils/csvImporter');
-const { PurchaseOrderStatus, ReceivingStatus } = require('../types/status-codes');
-
-// Configure multer for file uploads
-const upload = multer({ dest: 'uploads/' });
-
-// Get unique brands
-router.get('/brands', async (req, res) => {
-    console.log('Brands endpoint hit:', {
-        url: req.url,
-        method: req.method,
-        headers: req.headers,
-        path: req.path
-    });
-    
-    try {
-        const pool = req.app.locals.pool;
-        console.log('Fetching brands from database...');
-        
-        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
-            WHERE p.visible = true
-            GROUP BY COALESCE(p.brand, 'Unbranded')
-            HAVING SUM(po.cost_price * po.received) >= 500
-            ORDER BY COALESCE(p.brand, 'Unbranded')
-        `);
-        
-        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' });
-    }
-});
-
-// Get all products with pagination, filtering, and sorting
-router.get('/', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    const page = parseInt(req.query.page) || 1;
-    const limit = parseInt(req.query.limit) || 50;
-    const offset = (page - 1) * limit;
-    const sortColumn = req.query.sort || 'title';
-    const sortDirection = req.query.order === 'desc' ? 'DESC' : 'ASC';
-
-    const conditions = ['p.visible = true'];
-    const params = [];
-    let paramCounter = 1;
-
-    // Add default replenishable filter unless explicitly showing non-replenishable
-    if (req.query.showNonReplenishable !== 'true') {
-      conditions.push('p.replenishable = true');
-    }
-
-    // Handle search filter
-    if (req.query.search) {
-      conditions.push(`(p.title ILIKE $${paramCounter} OR p.SKU ILIKE $${paramCounter} OR p.barcode ILIKE $${paramCounter})`);
-      const searchTerm = `%${req.query.search}%`;
-      params.push(searchTerm);
-      paramCounter++;
-    }
-
-    // Handle numeric filters with operators
-    const numericFields = {
-      stock: 'p.stock_quantity',
-      price: 'p.price',
-      costPrice: 'p.cost_price',
-      landingCost: 'p.landing_cost_price',
-      dailySalesAvg: 'pm.daily_sales_avg',
-      weeklySalesAvg: 'pm.weekly_sales_avg',
-      monthlySalesAvg: 'pm.monthly_sales_avg',
-      margin: 'pm.avg_margin_percent',
-      gmroi: 'pm.gmroi',
-      leadTime: 'pm.current_lead_time',
-      stockCoverage: 'pm.days_of_inventory',
-      daysOfStock: 'pm.days_of_inventory'
-    };
-
-    Object.entries(req.query).forEach(([key, value]) => {
-      const field = numericFields[key];
-      if (field) {
-        const operator = req.query[`${key}_operator`] || '=';
-        if (operator === 'between') {
-          try {
-            const [min, max] = JSON.parse(value);
-            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 {
-          conditions.push(`${field} ${operator} $${paramCounter}`);
-          params.push(parseFloat(value));
-          paramCounter++;
-        }
-      }
-    });
-
-    // Handle select filters
-    if (req.query.vendor) {
-      conditions.push(`p.vendor = $${paramCounter}`);
-      params.push(req.query.vendor);
-      paramCounter++;
-    }
-
-    if (req.query.brand) {
-      conditions.push(`p.brand = $${paramCounter}`);
-      params.push(req.query.brand);
-      paramCounter++;
-    }
-
-    if (req.query.category) {
-      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 = $${paramCounter}`);
-      params.push(req.query.stockStatus);
-      paramCounter++;
-    }
-
-    if (req.query.abcClass) {
-      conditions.push(`pm.abc_class = $${paramCounter}`);
-      params.push(req.query.abcClass);
-      paramCounter++;
-    }
-
-    if (req.query.leadTimeStatus) {
-      conditions.push(`pm.lead_time_status = $${paramCounter}`);
-      params.push(req.query.leadTimeStatus);
-      paramCounter++;
-    }
-
-    if (req.query.replenishable !== undefined) {
-      conditions.push(`p.replenishable = $${paramCounter}`);
-      params.push(req.query.replenishable === 'true');
-      paramCounter++;
-    }
-
-    if (req.query.managingStock !== undefined) {
-      conditions.push(`p.managing_stock = $${paramCounter}`);
-      params.push(req.query.managingStock === 'true');
-      paramCounter++;
-    }
-
-    // Combine all conditions with AND
-    const whereClause = conditions.length > 0 ? 'WHERE ' + conditions.join(' AND ') : '';
-
-    // Get total count for pagination
-    const countQuery = `
-      SELECT COUNT(DISTINCT p.pid) as total 
-      FROM products p
-      LEFT JOIN product_metrics pm ON p.pid = pm.pid
-      ${whereClause}
-    `;
-    const { rows: [countResult] } = await pool.query(countQuery, params);
-    const total = countResult.total;
-
-    // Get available filters
-    const { rows: categories } = await pool.query(
-      'SELECT name FROM categories ORDER BY name'
-    );
-    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 { rows: brands } = await pool.query(
-      'SELECT DISTINCT COALESCE(brand, \'Unbranded\') as brand FROM products WHERE visible = true ORDER BY brand'
-    );
-
-    // Main query with all fields
-    const query = `
-      WITH RECURSIVE 
-        category_path AS (
-          SELECT 
-            c.cat_id,
-            c.name,
-            c.parent_id,
-            c.name::text as path
-          FROM categories c
-          WHERE c.parent_id IS NULL
-          
-          UNION ALL
-          
-          SELECT 
-            c.cat_id,
-            c.name,
-            c.parent_id,
-            (cp.path || ' > ' || c.name)::text
-          FROM categories c
-          JOIN category_path cp ON c.parent_id = cp.cat_id
-        ),
-        product_thresholds AS (
-          SELECT 
-            p.pid,
-            COALESCE(
-              (SELECT overstock_days FROM stock_thresholds st 
-               WHERE st.category_id IN (
-                 SELECT pc.cat_id 
-                 FROM product_categories pc 
-                 WHERE pc.pid = p.pid
-               )
-               AND (st.vendor = p.vendor OR st.vendor IS NULL)
-               ORDER BY st.vendor IS NULL
-               LIMIT 1),
-              (SELECT overstock_days FROM stock_thresholds st 
-               WHERE st.category_id IS NULL 
-               AND (st.vendor = p.vendor OR st.vendor IS NULL)
-               ORDER BY st.vendor IS NULL
-               LIMIT 1),
-              90
-            ) as target_days
-          FROM products p
-        ),
-        product_leaf_categories AS (
-          SELECT DISTINCT pc.cat_id
-          FROM product_categories pc
-          WHERE NOT EXISTS (
-            SELECT 1 
-            FROM categories child
-            JOIN product_categories child_pc ON child.cat_id = child_pc.cat_id
-            WHERE child.parent_id = pc.cat_id
-            AND child_pc.pid = pc.pid
-          )
-        )
-      SELECT 
-        p.*,
-        COALESCE(p.brand, 'Unbranded') as brand,
-        string_agg(DISTINCT (c.cat_id || ':' || c.name), ',') as categories,
-        pm.daily_sales_avg,
-        pm.weekly_sales_avg,
-        pm.monthly_sales_avg,
-        pm.avg_quantity_per_order,
-        pm.number_of_orders,
-        pm.first_sale_date,
-        pm.last_sale_date,
-        pm.days_of_inventory,
-        pm.weeks_of_inventory,
-        pm.reorder_point,
-        pm.safety_stock,
-        pm.avg_margin_percent,
-        CAST(pm.total_revenue AS DECIMAL(15,3)) as total_revenue,
-        CAST(pm.inventory_value AS DECIMAL(15,3)) as inventory_value,
-        CAST(pm.cost_of_goods_sold AS DECIMAL(15,3)) as cost_of_goods_sold,
-        CAST(pm.gross_profit AS DECIMAL(15,3)) as gross_profit,
-        pm.gmroi,
-        pm.avg_lead_time_days,
-        pm.last_purchase_date,
-        pm.last_received_date,
-        pm.abc_class,
-        pm.stock_status,
-        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
-      ${whereClause}
-      GROUP BY p.pid, pm.pid
-      ORDER BY ${sortColumn} ${sortDirection}
-      LIMIT $${paramCounter} OFFSET $${paramCounter + 1}
-    `;
-    
-    params.push(limit, offset);
-    const { rows: products } = await pool.query(query, params);
-
-    res.json({
-      products,
-      pagination: {
-        total,
-        pages: Math.ceil(total / limit),
-        currentPage: page,
-        limit
-      },
-      filters: {
-        categories: categories.map(c => c.name),
-        vendors: vendors.map(v => v.vendor),
-        brands: brands.map(b => b.brand)
-      }
-    });
-  } catch (error) {
-    console.error('Error fetching products:', error);
-    res.status(500).json({ error: 'Failed to fetch products' });
-  }
-});
-
-// Get trending products
-router.get('/trending', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    // First check if we have any data
-    const { rows } = await pool.query(`
-      SELECT COUNT(*) as count, 
-             MAX(total_revenue) as max_revenue,
-             MAX(daily_sales_avg) as max_daily_sales,
-             COUNT(DISTINCT pid) as products_with_metrics
-      FROM product_metrics 
-      WHERE total_revenue > 0 OR daily_sales_avg > 0
-    `);
-    console.log('Product metrics stats:', rows[0]);
-
-    if (parseInt(rows[0].count) === 0) {
-      console.log('No products with metrics found');
-      return res.json([]);
-    }
-
-    // Get trending products
-    const { rows: trendingProducts } = await pool.query(`
-      SELECT 
-        p.pid,
-        p.sku,
-        p.title,
-        COALESCE(pm.daily_sales_avg, 0) as daily_sales_avg,
-        COALESCE(pm.weekly_sales_avg, 0) as weekly_sales_avg,
-        CASE 
-          WHEN pm.weekly_sales_avg > 0 AND pm.daily_sales_avg > 0
-          THEN ((pm.daily_sales_avg - pm.weekly_sales_avg) / pm.weekly_sales_avg) * 100
-          ELSE 0 
-        END as growth_rate,
-        COALESCE(pm.total_revenue, 0) as total_revenue
-      FROM products p
-      INNER JOIN product_metrics pm ON p.pid = pm.pid
-      WHERE (pm.total_revenue > 0 OR pm.daily_sales_avg > 0)
-        AND p.visible = true
-      ORDER BY growth_rate DESC
-      LIMIT 50
-    `);
-
-    console.log('Trending products:', trendingProducts);
-    res.json(trendingProducts);
-  } catch (error) {
-    console.error('Error fetching trending products:', error);
-    res.status(500).json({ error: 'Failed to fetch trending products' });
-  }
-});
-
-// Get a single product
-router.get('/:id', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    const id = parseInt(req.params.id);
-
-    // Common CTE for category paths
-    const categoryPathCTE = `
-      WITH RECURSIVE category_path AS (
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          c.name::text as path
-        FROM categories c
-        WHERE c.parent_id IS NULL
-        
-        UNION ALL
-        
-        SELECT 
-          c.cat_id,
-          c.name,
-          c.parent_id,
-          (cp.path || ' > ' || c.name)::text
-        FROM categories c
-        JOIN category_path cp ON c.parent_id = cp.cat_id
-      )
-    `;
-
-    // Get product details with category paths
-    const { rows: productRows } = await pool.query(`
-      SELECT 
-        p.*,
-        pm.daily_sales_avg,
-        pm.weekly_sales_avg,
-        pm.monthly_sales_avg,
-        pm.days_of_inventory,
-        pm.reorder_point,
-        pm.safety_stock,
-        pm.stock_status,
-        pm.abc_class,
-        pm.avg_margin_percent,
-        pm.total_revenue,
-        pm.inventory_value,
-        pm.turnover_rate,
-        pm.gmroi,
-        pm.cost_of_goods_sold,
-        pm.gross_profit,
-        pm.avg_lead_time_days,
-        pm.current_lead_time,
-        pm.target_lead_time,
-        pm.lead_time_status,
-        pm.reorder_qty,
-        pm.overstocked_amt
-      FROM products p
-      LEFT JOIN product_metrics pm ON p.pid = pm.pid
-      WHERE p.pid = $1
-    `, [id]);
-
-    if (!productRows.length) {
-      return res.status(404).json({ error: 'Product not found' });
-    }
-
-    // Get categories and their paths separately to avoid GROUP BY issues
-    const { rows: categoryRows } = await pool.query(`
-      WITH RECURSIVE 
-        category_path AS (
-          SELECT 
-            c.cat_id,
-            c.name,
-            c.parent_id,
-            c.name::text as path
-          FROM categories c
-          WHERE c.parent_id IS NULL
-          
-          UNION ALL
-          
-          SELECT 
-            c.cat_id,
-            c.name,
-            c.parent_id,
-            (cp.path || ' > ' || c.name)::text
-          FROM categories c
-          JOIN category_path cp ON c.parent_id = cp.cat_id
-        ),
-        product_leaf_categories AS (
-          -- Find categories assigned to this product that aren't parents
-          -- of other categories assigned to this product
-          SELECT pc.cat_id
-          FROM product_categories pc
-          WHERE pc.pid = $1
-          AND NOT EXISTS (
-            -- Check if there are any child categories also assigned to this product
-            SELECT 1 
-            FROM categories child
-            JOIN product_categories child_pc ON child.cat_id = child_pc.cat_id
-            WHERE child.parent_id = pc.cat_id
-            AND child_pc.pid = pc.pid
-          )
-        )
-      SELECT 
-        c.cat_id,
-        c.name as category_name,
-        cp.path as full_path
-      FROM product_categories pc
-      JOIN categories c ON pc.cat_id = c.cat_id
-      JOIN category_path cp ON c.cat_id = cp.cat_id
-      JOIN product_leaf_categories plc ON c.cat_id = plc.cat_id
-      WHERE pc.pid = $2
-      ORDER BY cp.path
-    `, [id, id]);
-
-    // Transform the results
-    const categoryPathMap = categoryRows.reduce((acc, row) => {
-      // Use cat_id in the key to differentiate categories with the same name
-      acc[`${row.cat_id}:${row.category_name}`] = row.full_path;
-      return acc;
-    }, {});
-
-    const product = {
-      ...productRows[0],
-      // Include cat_id in categories array to match the keys in categoryPathMap
-      categories: categoryRows.map(row => `${row.cat_id}:${row.category_name}`),
-      category_paths: categoryPathMap,
-      price: parseFloat(productRows[0].price),
-      regular_price: parseFloat(productRows[0].regular_price),
-      cost_price: parseFloat(productRows[0].cost_price),
-      landing_cost_price: parseFloat(productRows[0].landing_cost_price),
-      stock_quantity: parseInt(productRows[0].stock_quantity),
-      moq: parseInt(productRows[0].moq),
-      uom: parseInt(productRows[0].uom),
-      managing_stock: Boolean(productRows[0].managing_stock),
-      replenishable: Boolean(productRows[0].replenishable),
-      daily_sales_avg: parseFloat(productRows[0].daily_sales_avg) || 0,
-      weekly_sales_avg: parseFloat(productRows[0].weekly_sales_avg) || 0,
-      monthly_sales_avg: parseFloat(productRows[0].monthly_sales_avg) || 0,
-      avg_quantity_per_order: parseFloat(productRows[0].avg_quantity_per_order) || 0,
-      number_of_orders: parseInt(productRows[0].number_of_orders) || 0,
-      first_sale_date: productRows[0].first_sale_date || null,
-      last_sale_date: productRows[0].last_sale_date || null,
-      days_of_inventory: parseFloat(productRows[0].days_of_inventory) || 0,
-      weeks_of_inventory: parseFloat(productRows[0].weeks_of_inventory) || 0,
-      reorder_point: parseFloat(productRows[0].reorder_point) || 0,
-      safety_stock: parseFloat(productRows[0].safety_stock) || 0,
-      avg_margin_percent: parseFloat(productRows[0].avg_margin_percent) || 0,
-      total_revenue: parseFloat(productRows[0].total_revenue) || 0,
-      inventory_value: parseFloat(productRows[0].inventory_value) || 0,
-      cost_of_goods_sold: parseFloat(productRows[0].cost_of_goods_sold) || 0,
-      gross_profit: parseFloat(productRows[0].gross_profit) || 0,
-      gmroi: parseFloat(productRows[0].gmroi) || 0,
-      avg_lead_time_days: parseFloat(productRows[0].avg_lead_time_days) || 0,
-      current_lead_time: parseFloat(productRows[0].current_lead_time) || 0,
-      target_lead_time: parseFloat(productRows[0].target_lead_time) || 0,
-      lead_time_status: productRows[0].lead_time_status || null,
-      reorder_qty: parseInt(productRows[0].reorder_qty) || 0,
-      overstocked_amt: parseInt(productRows[0].overstocked_amt) || 0
-    };
-
-    res.json(product);
-  } catch (error) {
-    console.error('Error fetching product:', error);
-    res.status(500).json({ error: 'Failed to fetch product' });
-  }
-});
-
-// Import products from CSV
-router.post('/import', upload.single('file'), async (req, res) => {
-  if (!req.file) {
-    return res.status(400).json({ error: 'No file uploaded' });
-  }
-
-  try {
-    const result = await importProductsFromCSV(req.file.path, req.app.locals.pool);
-    // Clean up the uploaded file
-    require('fs').unlinkSync(req.file.path);
-    res.json(result);
-  } catch (error) {
-    console.error('Error importing products:', error);
-    res.status(500).json({ error: 'Failed to import products' });
-  }
-});
-
-// Update a product
-router.put('/:id', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    const {
-      title,
-      sku,
-      stock_quantity,
-      price,
-      regular_price,
-      cost_price,
-      vendor,
-      brand,
-      categories,
-      visible,
-      managing_stock
-    } = req.body;
-
-    const { rowCount } = await pool.query(
-      `UPDATE products 
-       SET title = $1,
-           sku = $2,
-           stock_quantity = $3,
-           price = $4,
-           regular_price = $5,
-           cost_price = $6,
-           vendor = $7,
-           brand = $8,
-           categories = $9,
-           visible = $10,
-           managing_stock = $11
-       WHERE pid = $12`,
-      [
-        title,
-        sku,
-        stock_quantity,
-        price,
-        regular_price,
-        cost_price,
-        vendor,
-        brand,
-        categories,
-        visible,
-        managing_stock,
-        req.params.id
-      ]
-    );
-
-    if (rowCount === 0) {
-      return res.status(404).json({ error: 'Product not found' });
-    }
-
-    res.json({ message: 'Product updated successfully' });
-  } catch (error) {
-    console.error('Error updating product:', error);
-    res.status(500).json({ error: 'Failed to update product' });
-  }
-});
-
-// Get product metrics
-router.get('/:id/metrics', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    const { id } = req.params;
-    
-    // Get metrics from product_metrics table with inventory health data
-    const { rows: metrics } = await pool.query(`
-      WITH inventory_status AS (
-        SELECT 
-          p.pid,
-          CASE 
-            WHEN pm.daily_sales_avg = 0 THEN 'New'
-            WHEN p.stock_quantity <= CEIL(pm.daily_sales_avg * 7) THEN 'Critical'
-            WHEN p.stock_quantity <= CEIL(pm.daily_sales_avg * 14) THEN 'Reorder'
-            WHEN p.stock_quantity > (pm.daily_sales_avg * 90) THEN 'Overstocked'
-            ELSE 'Healthy'
-          END as calculated_status
-        FROM products p
-        LEFT JOIN product_metrics pm ON p.pid = pm.pid
-        WHERE p.pid = $1
-      )
-      SELECT 
-        COALESCE(pm.daily_sales_avg, 0) as daily_sales_avg,
-        COALESCE(pm.weekly_sales_avg, 0) as weekly_sales_avg,
-        COALESCE(pm.monthly_sales_avg, 0) as monthly_sales_avg,
-        COALESCE(pm.days_of_inventory, 0) as days_of_inventory,
-        COALESCE(pm.reorder_point, CEIL(COALESCE(pm.daily_sales_avg, 0) * 14)) as reorder_point,
-        COALESCE(pm.safety_stock, CEIL(COALESCE(pm.daily_sales_avg, 0) * 7)) as safety_stock,
-        COALESCE(pm.avg_margin_percent, 
-          ((p.price - COALESCE(p.cost_price, 0)) / NULLIF(p.price, 0)) * 100
-        ) as avg_margin_percent,
-        COALESCE(pm.total_revenue, 0) as total_revenue,
-        COALESCE(pm.inventory_value, p.stock_quantity * COALESCE(p.cost_price, 0)) as inventory_value,
-        COALESCE(pm.turnover_rate, 0) as turnover_rate,
-        COALESCE(pm.abc_class, 'C') as abc_class,
-        COALESCE(pm.stock_status, is.calculated_status) as stock_status,
-        COALESCE(pm.avg_lead_time_days, 0) as avg_lead_time_days,
-        COALESCE(pm.current_lead_time, 0) as current_lead_time,
-        COALESCE(pm.target_lead_time, 14) as target_lead_time,
-        COALESCE(pm.lead_time_status, 'Unknown') as lead_time_status,
-        COALESCE(pm.reorder_qty, 0) as reorder_qty,
-        COALESCE(pm.overstocked_amt, 0) as overstocked_amt
-      FROM products p
-      LEFT JOIN product_metrics pm ON p.pid = pm.pid
-      LEFT JOIN inventory_status is ON p.pid = is.pid
-      WHERE p.pid = $2
-    `, [id, id]);
-
-    if (!metrics.length) {
-      // Return default metrics structure if no data found
-      res.json({
-        daily_sales_avg: 0,
-        weekly_sales_avg: 0,
-        monthly_sales_avg: 0,
-        days_of_inventory: 0,
-        reorder_point: 0,
-        safety_stock: 0,
-        avg_margin_percent: 0,
-        total_revenue: 0,
-        inventory_value: 0,
-        turnover_rate: 0,
-        abc_class: 'C',
-        stock_status: 'New',
-        avg_lead_time_days: 0,
-        current_lead_time: 0,
-        target_lead_time: 14,
-        lead_time_status: 'Unknown',
-        reorder_qty: 0,
-        overstocked_amt: 0
-      });
-      return;
-    }
-
-    res.json(metrics[0]);
-  } catch (error) {
-    console.error('Error fetching product metrics:', error);
-    res.status(500).json({ error: 'Failed to fetch product metrics' });
-  }
-});
-
-// Get product time series data
-router.get('/:id/time-series', async (req, res) => {
-  const { id } = req.params;
-  try {
-    const pool = req.app.locals.pool;
-
-    // Get monthly sales data
-    const { rows: monthlySales } = await pool.query(`
-      SELECT 
-        TO_CHAR(date, 'YYYY-MM') as month,
-        COUNT(DISTINCT order_number) as order_count,
-        SUM(quantity) as units_sold,
-        ROUND(SUM(price * quantity)::numeric, 3) as revenue
-      FROM orders
-      WHERE pid = $1
-        AND canceled = false
-      GROUP BY TO_CHAR(date, 'YYYY-MM')
-      ORDER BY month DESC
-      LIMIT 12
-    `, [id]);
-
-    // Format monthly sales data
-    const formattedMonthlySales = monthlySales.map(month => ({
-      month: month.month,
-      order_count: parseInt(month.order_count),
-      units_sold: parseInt(month.units_sold),
-      revenue: parseFloat(month.revenue),
-      profit: 0 // Set to 0 since we don't have cost data in orders table
-    }));
-
-    // Get recent orders
-    const { rows: recentOrders } = await pool.query(`
-      SELECT 
-        TO_CHAR(date, 'YYYY-MM-DD') as date,
-        order_number,
-        quantity,
-        price,
-        discount,
-        tax,
-        shipping,
-        customer_name as customer,
-        status
-      FROM orders 
-      WHERE pid = $1
-        AND canceled = false
-      ORDER BY date DESC
-      LIMIT 10
-    `, [id]);
-
-    // Get recent purchase orders with detailed status
-    const { rows: recentPurchases } = await pool.query(`
-      SELECT 
-        TO_CHAR(date, 'YYYY-MM-DD') as date,
-        TO_CHAR(expected_date, 'YYYY-MM-DD') as expected_date,
-        TO_CHAR(received_date, 'YYYY-MM-DD') as received_date,
-        po_id,
-        ordered,
-        received,
-        status,
-        receiving_status,
-        cost_price,
-        notes,
-        CASE 
-          WHEN received_date IS NOT NULL THEN 
-            (received_date - date)
-          WHEN expected_date < CURRENT_DATE AND status < $2 THEN 
-            (CURRENT_DATE - expected_date)
-          ELSE NULL 
-        END as lead_time_days
-      FROM purchase_orders 
-      WHERE pid = $1
-        AND status != $3
-      ORDER BY date DESC
-      LIMIT 10
-    `, [id, PurchaseOrderStatus.ReceivingStarted, PurchaseOrderStatus.Canceled]);
-
-    res.json({
-      monthly_sales: formattedMonthlySales,
-      recent_orders: recentOrders.map(order => ({
-        ...order,
-        price: parseFloat(order.price),
-        discount: parseFloat(order.discount),
-        tax: parseFloat(order.tax),
-        shipping: parseFloat(order.shipping),
-        quantity: parseInt(order.quantity)
-      })),
-      recent_purchases: recentPurchases.map(po => ({
-        ...po,
-        ordered: parseInt(po.ordered),
-        received: parseInt(po.received),
-        status: parseInt(po.status),
-        receiving_status: parseInt(po.receiving_status),
-        cost_price: parseFloat(po.cost_price),
-        lead_time_days: po.lead_time_days ? parseInt(po.lead_time_days) : null
-      }))
-    });
-  } catch (error) {
-    console.error('Error fetching product time series:', error);
-    res.status(500).json({ error: 'Failed to fetch product time series' });
-  }
-});
-
-module.exports = router; 

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

@@ -1,461 +0,0 @@
-const express = require('express');
-const router = express.Router();
-
-// Status code constants
-const STATUS = {
-  CANCELED: 0,
-  CREATED: 1,
-  ELECTRONICALLY_READY_SEND: 10,
-  ORDERED: 11,
-  PREORDERED: 12,
-  ELECTRONICALLY_SENT: 13,
-  RECEIVING_STARTED: 15,
-  DONE: 50
-};
-
-const RECEIVING_STATUS = {
-  CANCELED: 0,
-  CREATED: 1,
-  PARTIAL_RECEIVED: 30,
-  FULL_RECEIVED: 40,
-  PAID: 50
-};
-
-// Get all purchase orders with summary metrics
-router.get('/', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    const { search, status, vendor, startDate, endDate, page = 1, limit = 100, sortColumn = 'date', sortDirection = 'desc' } = req.query;
-    
-    let whereClause = '1=1';
-    const params = [];
-    let paramCounter = 1;
-    
-    if (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 = $${paramCounter}`;
-      params.push(Number(status));
-      paramCounter++;
-    }
-    
-    if (vendor && vendor !== 'all') {
-      whereClause += ` AND po.vendor = $${paramCounter}`;
-      params.push(vendor);
-      paramCounter++;
-    }
-    
-    if (startDate) {
-      whereClause += ` AND po.date >= $${paramCounter}`;
-      params.push(startDate);
-      paramCounter++;
-    }
-    
-    if (endDate) {
-      whereClause += ` AND po.date <= $${paramCounter}`;
-      params.push(endDate);
-      paramCounter++;
-    }
-
-    // Get filtered summary metrics
-    const { rows: [summary] } = await pool.query(`
-      WITH po_totals AS (
-        SELECT 
-          po_id,
-          SUM(ordered) as total_ordered,
-          SUM(received) as total_received,
-          ROUND(SUM(ordered * cost_price)::numeric, 3) as total_cost
-        FROM purchase_orders po
-        WHERE ${whereClause}
-        GROUP BY po_id
-      )
-      SELECT 
-        COUNT(DISTINCT po_id) as order_count,
-        SUM(total_ordered) as total_ordered,
-        SUM(total_received) as total_received,
-        ROUND(
-          (SUM(total_received)::numeric / NULLIF(SUM(total_ordered), 0)), 3
-        ) as fulfillment_rate,
-        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 { rows: [countResult] } = await pool.query(`
-      SELECT COUNT(DISTINCT po_id) as total
-      FROM purchase_orders po
-      WHERE ${whereClause}
-    `, params);
-
-    const total = countResult.total;
-    const offset = (page - 1) * limit;
-    const pages = Math.ceil(total / limit);
-
-    // Get recent purchase orders
-    let orderByClause;
-    
-    if (sortColumn === 'order_date') {
-      orderByClause = `date ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    } else if (sortColumn === 'vendor_name') {
-      orderByClause = `vendor ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    } else if (sortColumn === 'total_cost') {
-      orderByClause = `total_cost ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    } else if (sortColumn === 'total_received') {
-      orderByClause = `total_received ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    } else if (sortColumn === 'total_items') {
-      orderByClause = `total_items ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    } else if (sortColumn === 'total_quantity') {
-      orderByClause = `total_quantity ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    } else if (sortColumn === 'fulfillment_rate') {
-      orderByClause = `fulfillment_rate ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    } else if (sortColumn === 'status') {
-      orderByClause = `status ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    } else {
-      orderByClause = `date ${sortDirection === 'desc' ? 'DESC' : 'ASC'}`;
-    }
-
-    const { rows: orders } = await pool.query(`
-      WITH po_totals AS (
-        SELECT 
-          po_id,
-          vendor,
-          date,
-          status,
-          receiving_status,
-          COUNT(DISTINCT pid) as total_items,
-          SUM(ordered) as total_quantity,
-          ROUND(SUM(ordered * cost_price)::numeric, 3) as total_cost,
-          SUM(received) as total_received,
-          ROUND(
-            (SUM(received)::numeric / NULLIF(SUM(ordered), 0)), 3
-          ) as fulfillment_rate
-        FROM purchase_orders po
-        WHERE ${whereClause}
-        GROUP BY po_id, vendor, date, status, receiving_status
-      )
-      SELECT 
-        po_id as id,
-        vendor as vendor_name,
-        to_char(date, 'YYYY-MM-DD') as order_date,
-        status,
-        receiving_status,
-        total_items,
-        total_quantity,
-        total_cost,
-        total_received,
-        fulfillment_rate
-      FROM po_totals
-      ORDER BY ${orderByClause}
-      LIMIT $${paramCounter} OFFSET $${paramCounter + 1}
-    `, [...params, Number(limit), offset]);
-
-    // Get unique vendors for filter options
-    const { rows: vendors } = await pool.query(`
-      SELECT DISTINCT vendor 
-      FROM purchase_orders 
-      WHERE vendor IS NOT NULL AND vendor != ''
-      ORDER BY vendor
-    `);
-
-    // Get unique statuses for filter options
-    const { rows: statuses } = await pool.query(`
-      SELECT DISTINCT status 
-      FROM purchase_orders 
-      WHERE status IS NOT NULL
-      ORDER BY status
-    `);
-
-    // Parse numeric values
-    const parsedOrders = orders.map(order => ({
-      id: order.id,
-      vendor_name: order.vendor_name,
-      order_date: order.order_date,
-      status: Number(order.status),
-      receiving_status: Number(order.receiving_status),
-      total_items: Number(order.total_items) || 0,
-      total_quantity: Number(order.total_quantity) || 0,
-      total_cost: Number(order.total_cost) || 0,
-      total_received: Number(order.total_received) || 0,
-      fulfillment_rate: Number(order.fulfillment_rate) || 0
-    }));
-
-    // Parse summary metrics
-    const parsedSummary = {
-      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({
-      orders: parsedOrders,
-      summary: parsedSummary,
-      pagination: {
-        total,
-        pages,
-        page: Number(page),
-        limit: Number(limit)
-      },
-      filters: {
-        vendors: vendors.map(v => v.vendor),
-        statuses: statuses.map(s => Number(s.status))
-      }
-    });
-  } catch (error) {
-    console.error('Error fetching purchase orders:', error);
-    res.status(500).json({ error: 'Failed to fetch purchase orders' });
-  }
-});
-
-// Get vendor performance metrics
-router.get('/vendor-metrics', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    const { rows: metrics } = await pool.query(`
-      WITH delivery_metrics AS (
-        SELECT 
-          vendor,
-          po_id,
-          ordered,
-          received,
-          cost_price,
-          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 (received_date - date)::integer
-            ELSE NULL
-          END as delivery_days
-        FROM purchase_orders
-        WHERE vendor IS NOT NULL AND vendor != ''
-          AND status != ${STATUS.CANCELED}  -- Exclude canceled orders
-      )
-      SELECT 
-        vendor as vendor_name,
-        COUNT(DISTINCT po_id) as total_orders,
-        SUM(ordered) as total_ordered,
-        SUM(received) as total_received,
-        ROUND(
-          (SUM(received)::numeric / NULLIF(SUM(ordered), 0)), 3
-        ) as fulfillment_rate,
-        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,
-        ROUND(
-          AVG(NULLIF(delivery_days, 0))::numeric, 1
-        ) as avg_delivery_days
-      FROM delivery_metrics
-      GROUP BY vendor
-      HAVING COUNT(DISTINCT po_id) > 0
-      ORDER BY total_spend DESC
-    `);
-
-    // Parse numeric values
-    const parsedMetrics = metrics.map(vendor => ({
-      id: vendor.vendor_name,
-      vendor_name: vendor.vendor_name,
-      total_orders: Number(vendor.total_orders) || 0,
-      total_ordered: Number(vendor.total_ordered) || 0,
-      total_received: Number(vendor.total_received) || 0,
-      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: Number(vendor.avg_delivery_days) || 0
-    }));
-
-    res.json(parsedMetrics);
-  } catch (error) {
-    console.error('Error fetching vendor metrics:', error);
-    res.status(500).json({ error: 'Failed to fetch vendor metrics' });
-  }
-});
-
-// Get cost analysis
-router.get('/cost-analysis', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    const { rows: analysis } = await pool.query(`
-      WITH category_costs AS (
-        SELECT 
-          c.name as category,
-          po.pid,
-          po.cost_price,
-          po.ordered,
-          po.received,
-          po.status,
-          po.receiving_status
-        FROM purchase_orders po
-        JOIN product_categories pc ON po.pid = pc.pid
-        JOIN categories c ON pc.cat_id = c.cat_id
-        WHERE po.status != ${STATUS.CANCELED}  -- Exclude canceled orders
-      )
-      SELECT 
-        category,
-        COUNT(DISTINCT pid) as unique_products,
-        ROUND(AVG(cost_price)::numeric, 3) as avg_cost,
-        ROUND(MIN(cost_price)::numeric, 3) as min_cost,
-        ROUND(MAX(cost_price)::numeric, 3) as max_cost,
-        ROUND(STDDEV(cost_price)::numeric, 3) as cost_variance,
-        ROUND(SUM(ordered * cost_price)::numeric, 3) as total_spend
-      FROM category_costs
-      GROUP BY category
-      ORDER BY total_spend DESC
-    `);
-
-    // Parse numeric values
-    const parsedAnalysis = {
-      unique_products: 0,
-      avg_cost: 0,
-      min_cost: 0,
-      max_cost: 0,
-      cost_variance: 0,
-      total_spend_by_category: analysis.map(cat => ({
-        category: cat.category,
-        total_spend: Number(cat.total_spend) || 0
-      }))
-    };
-
-    // Calculate aggregated stats if data exists
-    if (analysis.length > 0) {
-      parsedAnalysis.unique_products = analysis.reduce((sum, cat) => sum + Number(cat.unique_products || 0), 0);
-      
-      // Calculate weighted average cost
-      const totalProducts = parsedAnalysis.unique_products;
-      if (totalProducts > 0) {
-        parsedAnalysis.avg_cost = analysis.reduce((sum, cat) => 
-          sum + (Number(cat.avg_cost || 0) * Number(cat.unique_products || 0)), 0) / totalProducts;
-      }
-      
-      // Find min and max across all categories
-      parsedAnalysis.min_cost = Math.min(...analysis.map(cat => Number(cat.min_cost || 0)));
-      parsedAnalysis.max_cost = Math.max(...analysis.map(cat => Number(cat.max_cost || 0)));
-      
-      // Average variance
-      parsedAnalysis.cost_variance = analysis.reduce((sum, cat) => 
-        sum + Number(cat.cost_variance || 0), 0) / analysis.length;
-    }
-
-    res.json(parsedAnalysis);
-  } catch (error) {
-    console.error('Error fetching cost analysis:', error);
-    res.status(500).json({ error: 'Failed to fetch cost analysis' });
-  }
-});
-
-// Get receiving status metrics
-router.get('/receiving-status', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    const { rows: status } = await pool.query(`
-      WITH po_totals AS (
-        SELECT 
-          po_id,
-          status,
-          receiving_status,
-          SUM(ordered) as total_ordered,
-          SUM(received) as total_received,
-          ROUND(SUM(ordered * cost_price)::numeric, 3) as total_cost
-        FROM purchase_orders
-        WHERE status != ${STATUS.CANCELED}
-        GROUP BY po_id, status, receiving_status
-      )
-      SELECT 
-        COUNT(DISTINCT po_id) as order_count,
-        SUM(total_ordered) as total_ordered,
-        SUM(total_received) as total_received,
-        ROUND(
-          SUM(total_received) / NULLIF(SUM(total_ordered), 0), 3
-        ) as fulfillment_rate,
-        ROUND(SUM(total_cost)::numeric, 3) as total_value,
-        ROUND(AVG(total_cost)::numeric, 3) as avg_cost,
-        COUNT(DISTINCT CASE 
-          WHEN receiving_status = ${RECEIVING_STATUS.CREATED} THEN po_id 
-          END) as pending_count,
-        COUNT(DISTINCT CASE 
-          WHEN receiving_status = ${RECEIVING_STATUS.PARTIAL_RECEIVED} THEN po_id 
-          END) as partial_count,
-        COUNT(DISTINCT CASE 
-          WHEN receiving_status >= ${RECEIVING_STATUS.FULL_RECEIVED} THEN po_id 
-          END) as completed_count,
-        COUNT(DISTINCT CASE 
-          WHEN receiving_status = ${RECEIVING_STATUS.CANCELED} THEN po_id 
-          END) as canceled_count
-      FROM po_totals
-    `);
-
-    // Parse numeric values
-    const parsedStatus = {
-      order_count: Number(status[0]?.order_count) || 0,
-      total_ordered: Number(status[0]?.total_ordered) || 0,
-      total_received: Number(status[0]?.total_received) || 0,
-      fulfillment_rate: Number(status[0]?.fulfillment_rate) || 0,
-      total_value: Number(status[0]?.total_value) || 0,
-      avg_cost: Number(status[0]?.avg_cost) || 0,
-      status_breakdown: {
-        pending: Number(status[0]?.pending_count) || 0,
-        partial: Number(status[0]?.partial_count) || 0,
-        completed: Number(status[0]?.completed_count) || 0,
-        canceled: Number(status[0]?.canceled_count) || 0
-      }
-    };
-
-    res.json(parsedStatus);
-  } catch (error) {
-    console.error('Error fetching receiving status:', error);
-    res.status(500).json({ error: 'Failed to fetch receiving status' });
-  }
-});
-
-// Get order vs received quantities by product
-router.get('/order-vs-received', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    
-    const { rows: quantities } = await pool.query(`
-      SELECT 
-        p.product_id,
-        p.title as product,
-        p.SKU as sku,
-        SUM(po.ordered) as ordered_quantity,
-        SUM(po.received) as received_quantity,
-        ROUND(
-          SUM(po.received) / NULLIF(SUM(po.ordered), 0) * 100, 1
-        ) as fulfillment_rate,
-        COUNT(DISTINCT po.po_id) as order_count
-      FROM products p
-      JOIN purchase_orders po ON p.product_id = po.product_id
-      WHERE po.date >= (CURRENT_DATE - INTERVAL '90 days')
-      GROUP BY p.product_id, p.title, p.SKU
-      HAVING COUNT(DISTINCT po.po_id) > 0
-      ORDER BY SUM(po.ordered) DESC
-      LIMIT 20
-    `);
-
-    // Parse numeric values and add id for React keys
-    const parsedQuantities = quantities.map(q => ({
-      id: q.product_id,
-      ...q,
-      ordered_quantity: Number(q.ordered_quantity),
-      received_quantity: Number(q.received_quantity),
-      fulfillment_rate: Number(q.fulfillment_rate),
-      order_count: Number(q.order_count)
-    }));
-
-    res.json(parsedQuantities);
-  } catch (error) {
-    console.error('Error fetching order vs received quantities:', error);
-    res.status(500).json({ error: 'Failed to fetch order vs received quantities' });
-  }
-});
-
-module.exports = router; 

inventory-server/src/routes/reusable-images.js

@@ -1,396 +0,0 @@
-const express = require('express');
-const router = express.Router();
-const multer = require('multer');
-const path = require('path');
-const fs = require('fs');
-
-// Create reusable uploads directory if it doesn't exist
-const uploadsDir = path.join('/var/www/html/inventory/uploads/reusable');
-fs.mkdirSync(uploadsDir, { recursive: true });
-
-// Configure multer for file uploads
-const storage = multer.diskStorage({
-  destination: function (req, file, cb) {
-    console.log(`Saving reusable image to: ${uploadsDir}`);
-    cb(null, uploadsDir);
-  },
-  filename: function (req, file, cb) {
-    // Create unique filename with original extension
-    const uniqueSuffix = Date.now() + '-' + Math.round(Math.random() * 1E9);
-    
-    // Make sure we preserve the original file extension
-    let fileExt = path.extname(file.originalname).toLowerCase();
-    
-    // Ensure there is a proper extension based on mimetype if none exists
-    if (!fileExt) {
-      switch (file.mimetype) {
-        case 'image/jpeg': fileExt = '.jpg'; break;
-        case 'image/png': fileExt = '.png'; break;
-        case 'image/gif': fileExt = '.gif'; break;
-        case 'image/webp': fileExt = '.webp'; break;
-        default: fileExt = '.jpg'; // Default to jpg
-      }
-    }
-    
-    const fileName = `reusable-${uniqueSuffix}${fileExt}`;
-    console.log(`Generated filename: ${fileName} with mimetype: ${file.mimetype}`);
-    cb(null, fileName);
-  }
-});
-
-const upload = multer({ 
-  storage: storage,
-  limits: {
-    fileSize: 5 * 1024 * 1024, // 5MB max file size
-  },
-  fileFilter: function (req, file, cb) {
-    // Accept only image files
-    const filetypes = /jpeg|jpg|png|gif|webp/;
-    const mimetype = filetypes.test(file.mimetype);
-    const extname = filetypes.test(path.extname(file.originalname).toLowerCase());
-    
-    if (mimetype && extname) {
-      return cb(null, true);
-    }
-    cb(new Error('Only image files are allowed'));
-  }
-});
-
-// Get all reusable images
-router.get('/', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      SELECT * FROM reusable_images 
-      ORDER BY created_at DESC
-    `);
-    res.json(result.rows);
-  } catch (error) {
-    console.error('Error fetching reusable images:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch reusable images',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Get images by company or global images
-router.get('/by-company/:companyId', async (req, res) => {
-  try {
-    const { companyId } = req.params;
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    // Get images that are either global or belong to this company
-    const result = await pool.query(`
-      SELECT * FROM reusable_images 
-      WHERE is_global = true OR company = $1
-      ORDER BY created_at DESC
-    `, [companyId]);
-    
-    res.json(result.rows);
-  } catch (error) {
-    console.error('Error fetching reusable images by company:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch reusable images by company',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Get global images only
-router.get('/global', async (req, res) => {
-  try {
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      SELECT * FROM reusable_images 
-      WHERE is_global = true
-      ORDER BY created_at DESC
-    `);
-    
-    res.json(result.rows);
-  } catch (error) {
-    console.error('Error fetching global reusable images:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch global reusable images',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Get a single image by ID
-router.get('/:id', async (req, res) => {
-  try {
-    const { id } = req.params;
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    const result = await pool.query(`
-      SELECT * FROM reusable_images 
-      WHERE id = $1
-    `, [id]);
-
-    if (result.rows.length === 0) {
-      return res.status(404).json({ error: 'Reusable image not found' });
-    }
-
-    res.json(result.rows[0]);
-  } catch (error) {
-    console.error('Error fetching reusable image:', error);
-    res.status(500).json({ 
-      error: 'Failed to fetch reusable image',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Upload a new reusable image
-router.post('/upload', upload.single('image'), async (req, res) => {
-  try {
-    if (!req.file) {
-      return res.status(400).json({ error: 'No image file provided' });
-    }
-
-    const { name, is_global, company } = req.body;
-    
-    // Validate required fields
-    if (!name) {
-      return res.status(400).json({ error: 'Image name is required' });
-    }
-    
-    // Convert is_global from string to boolean
-    const isGlobal = is_global === 'true' || is_global === true;
-    
-    // Validate company is provided for non-global images
-    if (!isGlobal && !company) {
-      return res.status(400).json({ error: 'Company is required for non-global images' });
-    }
-
-    // Log file information
-    console.log('Reusable image uploaded:', {
-      filename: req.file.filename,
-      originalname: req.file.originalname,
-      mimetype: req.file.mimetype,
-      size: req.file.size,
-      path: req.file.path
-    });
-
-    // Ensure the file exists
-    const filePath = path.join(uploadsDir, req.file.filename);
-    if (!fs.existsSync(filePath)) {
-      return res.status(500).json({ error: 'File was not saved correctly' });
-    }
-
-    // Create URL for the uploaded file
-    const baseUrl = 'https://inventory.acot.site';
-    const imageUrl = `${baseUrl}/uploads/reusable/${req.file.filename}`;
-    
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    // Insert record into database
-    const result = await pool.query(`
-      INSERT INTO reusable_images (
-        name,
-        filename,
-        file_path,
-        image_url,
-        is_global,
-        company,
-        mime_type,
-        file_size
-      ) VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
-      RETURNING *
-    `, [
-      name,
-      req.file.filename,
-      filePath,
-      imageUrl,
-      isGlobal,
-      isGlobal ? null : company,
-      req.file.mimetype,
-      req.file.size
-    ]);
-
-    // Return success response with image data
-    res.status(201).json({
-      success: true,
-      image: result.rows[0],
-      message: 'Image uploaded successfully'
-    });
-    
-  } catch (error) {
-    console.error('Error uploading reusable image:', error);
-    res.status(500).json({ error: error.message || 'Failed to upload image' });
-  }
-});
-
-// Update image details (name, is_global, company)
-router.put('/:id', async (req, res) => {
-  try {
-    const { id } = req.params;
-    const { name, is_global, company } = req.body;
-    
-    // Validate required fields
-    if (!name) {
-      return res.status(400).json({ error: 'Image name is required' });
-    }
-    
-    // Convert is_global from string to boolean if necessary
-    const isGlobal = typeof is_global === 'string' ? is_global === 'true' : !!is_global;
-    
-    // Validate company is provided for non-global images
-    if (!isGlobal && !company) {
-      return res.status(400).json({ error: 'Company is required for non-global images' });
-    }
-    
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    // Check if the image exists
-    const checkResult = await pool.query('SELECT * FROM reusable_images WHERE id = $1', [id]);
-    if (checkResult.rows.length === 0) {
-      return res.status(404).json({ error: 'Reusable image not found' });
-    }
-    
-    const result = await pool.query(`
-      UPDATE reusable_images 
-      SET 
-        name = $1,
-        is_global = $2,
-        company = $3
-      WHERE id = $4
-      RETURNING *
-    `, [
-      name,
-      isGlobal,
-      isGlobal ? null : company,
-      id
-    ]);
-
-    res.json(result.rows[0]);
-  } catch (error) {
-    console.error('Error updating reusable image:', error);
-    res.status(500).json({ 
-      error: 'Failed to update reusable image',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Delete a reusable image
-router.delete('/:id', async (req, res) => {
-  try {
-    const { id } = req.params;
-    const pool = req.app.locals.pool;
-    if (!pool) {
-      throw new Error('Database pool not initialized');
-    }
-    
-    // Get the image data first to get the filename
-    const imageResult = await pool.query('SELECT * FROM reusable_images WHERE id = $1', [id]);
-    
-    if (imageResult.rows.length === 0) {
-      return res.status(404).json({ error: 'Reusable image not found' });
-    }
-    
-    const image = imageResult.rows[0];
-    
-    // Delete from database
-    await pool.query('DELETE FROM reusable_images WHERE id = $1', [id]);
-    
-    // Delete the file from filesystem
-    const filePath = path.join(uploadsDir, image.filename);
-    if (fs.existsSync(filePath)) {
-      fs.unlinkSync(filePath);
-    }
-
-    res.json({ 
-      message: 'Reusable image deleted successfully',
-      image
-    });
-  } catch (error) {
-    console.error('Error deleting reusable image:', error);
-    res.status(500).json({ 
-      error: 'Failed to delete reusable image',
-      details: error instanceof Error ? error.message : 'Unknown error'
-    });
-  }
-});
-
-// Check if file exists and permissions
-router.get('/check-file/:filename', (req, res) => {
-  const { filename } = req.params;
-  
-  // Prevent directory traversal
-  if (filename.includes('..') || filename.includes('/')) {
-    return res.status(400).json({ error: 'Invalid filename' });
-  }
-  
-  const filePath = path.join(uploadsDir, filename);
-  
-  try {
-    // Check if file exists
-    if (!fs.existsSync(filePath)) {
-      return res.status(404).json({ 
-        error: 'File not found', 
-        path: filePath,
-        exists: false,
-        readable: false 
-      });
-    }
-    
-    // Check if file is readable
-    fs.accessSync(filePath, fs.constants.R_OK);
-    
-    // Get file stats
-    const stats = fs.statSync(filePath);
-    
-    return res.json({
-      filename,
-      path: filePath,
-      exists: true,
-      readable: true,
-      isFile: stats.isFile(),
-      isDirectory: stats.isDirectory(),
-      size: stats.size,
-      created: stats.birthtime,
-      modified: stats.mtime,
-      permissions: stats.mode.toString(8)
-    });
-  } catch (error) {
-    return res.status(500).json({ 
-      error: error.message,
-      path: filePath,
-      exists: fs.existsSync(filePath),
-      readable: false
-    });
-  }
-});
-
-// Error handling middleware
-router.use((err, req, res, next) => {
-  console.error('Reusable images route error:', err);
-  res.status(500).json({ 
-    error: 'Internal server error',
-    details: err.message
-  });
-});
-
-module.exports = router; 

inventory-server/src/routes/templates.js

@@ -1,283 +0,0 @@
-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

@@ -1,108 +0,0 @@
-const express = require('express');
-const router = express.Router();
-
-// Get vendors with pagination, filtering, and sorting
-router.get('/', async (req, res) => {
-  const pool = req.app.locals.pool;
-  try {
-    // Get all vendors with metrics
-    const { rows: vendors } = await pool.query(`
-      SELECT DISTINCT
-        p.vendor as name,
-        COALESCE(vm.active_products, 0) as active_products,
-        COALESCE(vm.total_orders, 0) as total_orders,
-        COALESCE(vm.avg_lead_time_days, 0) as avg_lead_time_days,
-        COALESCE(vm.on_time_delivery_rate, 0) as on_time_delivery_rate,
-        COALESCE(vm.order_fill_rate, 0) as order_fill_rate,
-        CASE 
-          WHEN COALESCE(vm.total_orders, 0) > 0 AND COALESCE(vm.order_fill_rate, 0) >= 75 THEN 'active'
-          WHEN COALESCE(vm.total_orders, 0) > 0 THEN 'inactive'
-          ELSE 'pending'
-        END as status
-      FROM products p
-      LEFT JOIN vendor_metrics vm ON p.vendor = vm.vendor
-      WHERE p.vendor IS NOT NULL AND p.vendor != ''
-    `);
-
-    // Get cost metrics for all vendors
-    const vendorNames = vendors.map(v => v.name);
-    const { rows: costMetrics } = await pool.query(`
-      SELECT 
-        vendor,
-        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 = 2
-        AND cost_price IS NOT NULL
-        AND ordered > 0
-        AND vendor = ANY($1)
-      GROUP BY vendor
-    `, [vendorNames]);
-
-    // Create a map of cost metrics by vendor
-    const costMetricsMap = costMetrics.reduce((acc, curr) => {
-      acc[curr.vendor] = {
-        avg_unit_cost: curr.avg_unit_cost,
-        total_spend: curr.total_spend
-      };
-      return acc;
-    }, {});
-
-    // Get overall stats
-    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))::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 { rows: [overallCostMetrics] } = await pool.query(`
-      SELECT 
-        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 = 2
-        AND cost_price IS NOT NULL
-        AND ordered > 0
-        AND vendor IS NOT NULL AND vendor != ''
-    `);
-
-    res.json({
-      vendors: vendors.map(vendor => ({
-        vendor_id: vendor.name,
-        name: vendor.name,
-        status: vendor.status,
-        avg_lead_time_days: parseFloat(vendor.avg_lead_time_days),
-        on_time_delivery_rate: parseFloat(vendor.on_time_delivery_rate),
-        order_fill_rate: parseFloat(vendor.order_fill_rate),
-        total_orders: parseInt(vendor.total_orders),
-        active_products: parseInt(vendor.active_products),
-        avg_unit_cost: parseFloat(costMetricsMap[vendor.name]?.avg_unit_cost || 0),
-        total_spend: parseFloat(costMetricsMap[vendor.name]?.total_spend || 0)
-      })),
-      stats: {
-        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) {
-    console.error('Error fetching vendors:', error);
-    res.status(500).json({ error: 'Failed to fetch vendors' });
-  }
-});
-
-module.exports = router; 

inventory-server/src/routes/vendorsAggregate.js

@@ -0,0 +1 @@
+ 

inventory-server/src/server.js

@@ -1,206 +0,0 @@
-const express = require('express');
-const cors = require('cors');
-const { spawn } = require('child_process');
-const path = require('path');
-const fs = require('fs');
-const { corsMiddleware, corsErrorHandler } = require('./middleware/cors');
-const { initPool } = require('./utils/db');
-const productsRouter = require('./routes/products');
-const dashboardRouter = require('./routes/dashboard');
-const ordersRouter = require('./routes/orders');
-const csvRouter = require('./routes/csv');
-const analyticsRouter = require('./routes/analytics');
-const purchaseOrdersRouter = require('./routes/purchase-orders');
-const configRouter = require('./routes/config');
-const metricsRouter = require('./routes/metrics');
-const vendorsRouter = require('./routes/vendors');
-const categoriesRouter = require('./routes/categories');
-const importRouter = require('./routes/import');
-const aiValidationRouter = require('./routes/ai-validation');
-const templatesRouter = require('./routes/templates');
-const aiPromptsRouter = require('./routes/ai-prompts');
-const reusableImagesRouter = require('./routes/reusable-images');
-
-// Get the absolute path to the .env file
-const envPath = '/var/www/html/inventory/.env';
-console.log('Looking for .env file at:', envPath);
-console.log('.env file exists:', fs.existsSync(envPath));
-
-try {
-  require('dotenv').config({ path: envPath });
-  console.log('.env file loaded successfully');
-  console.log('Environment check:', {
-    NODE_ENV: process.env.NODE_ENV || 'not set',
-    PORT: process.env.PORT || 'not set',
-    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);
-}
-
-// Ensure required directories exist
-['logs', 'uploads'].forEach(dir => {
-  if (!fs.existsSync(dir)) {
-    fs.mkdirSync(dir, { recursive: true });
-  }
-});
-
-const app = express();
-
-// 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
-  });
-  next();
-});
-
-// Apply CORS middleware first, before any other middleware
-app.use(corsMiddleware);
-
-// Body parser middleware
-app.use(express.json({ limit: '10mb' }));
-app.use(express.urlencoded({ extended: true, limit: '10mb' }));
-
-// 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;
-
-    // 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);
-    app.use('/api/ai-prompts', aiPromptsRouter);
-    app.use('/api/reusable-images', reusableImagesRouter);
-
-    // 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);
-
-    // 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) => {
-  console.error(`[${new Date().toISOString()}] Uncaught Exception:`, err);
-  process.exit(1);
-});
-
-process.on('unhandledRejection', (reason, promise) => {
-  console.error(`[${new Date().toISOString()}] Unhandled Rejection at:`, promise, 'reason:', reason);
-});
-
-// Initialize client sets for SSE
-const importClients = new Set();
-const updateClients = new Set();
-const resetClients = new Set();
-const resetMetricsClients = new Set();
-
-// Helper function to send progress to SSE clients
-const sendProgressToClients = (clients, data) => {
-  clients.forEach(client => {
-    try {
-      client.write(`data: ${JSON.stringify(data)}\n\n`);
-    } catch (error) {
-      console.error('Error sending SSE update:', error);
-    }
-  });
-};
-
-// Setup SSE connection
-const setupSSE = (req, res) => {
-  const { type } = req.params;
-  
-  // Set headers for SSE
-  res.writeHead(200, {
-    'Content-Type': 'text/event-stream',
-    'Cache-Control': 'no-cache',
-    'Connection': 'keep-alive',
-    'Access-Control-Allow-Origin': req.headers.origin || '*',
-    'Access-Control-Allow-Credentials': 'true'
-  });
-
-  // Send initial message
-  res.write('data: {"status":"connected"}\n\n');
-
-  // Add client to appropriate set
-  const clientSet = type === 'import' ? importClients :
-                   type === 'update' ? updateClients :
-                   type === 'reset' ? resetClients :
-                   type === 'reset-metrics' ? resetMetricsClients :
-                   null;
-
-  if (clientSet) {
-    clientSet.add(res);
-    
-    // Remove client when connection closes
-    req.on('close', () => {
-      clientSet.delete(res);
-    });
-  }
-};
-
-// Start the server
-startServer(); 

inventory-server/src/types/status-codes.js

@@ -1,79 +0,0 @@
-// Purchase Order Status Codes
-const PurchaseOrderStatus = {
-    Canceled: 0,
-    Created: 1,
-    ElectronicallyReadySend: 10,
-    Ordered: 11,
-    Preordered: 12,
-    ElectronicallySent: 13,
-    ReceivingStarted: 15,
-    Done: 50
-};
-
-// Receiving Status Codes
-const ReceivingStatus = {
-    Canceled: 0,
-    Created: 1,
-    PartialReceived: 30,
-    FullReceived: 40,
-    Paid: 50
-};
-
-// Status Code Display Names
-const PurchaseOrderStatusLabels = {
-    [PurchaseOrderStatus.Canceled]: 'Canceled',
-    [PurchaseOrderStatus.Created]: 'Created',
-    [PurchaseOrderStatus.ElectronicallyReadySend]: 'Ready to Send',
-    [PurchaseOrderStatus.Ordered]: 'Ordered',
-    [PurchaseOrderStatus.Preordered]: 'Preordered',
-    [PurchaseOrderStatus.ElectronicallySent]: 'Sent',
-    [PurchaseOrderStatus.ReceivingStarted]: 'Receiving Started',
-    [PurchaseOrderStatus.Done]: 'Done'
-};
-
-const ReceivingStatusLabels = {
-    [ReceivingStatus.Canceled]: 'Canceled',
-    [ReceivingStatus.Created]: 'Created',
-    [ReceivingStatus.PartialReceived]: 'Partially Received',
-    [ReceivingStatus.FullReceived]: 'Fully Received',
-    [ReceivingStatus.Paid]: 'Paid'
-};
-
-// Helper functions
-function getPurchaseOrderStatusLabel(status) {
-    return PurchaseOrderStatusLabels[status] || 'Unknown';
-}
-
-function getReceivingStatusLabel(status) {
-    return ReceivingStatusLabels[status] || 'Unknown';
-}
-
-// Status checks
-function isReceivingComplete(status) {
-    return status >= ReceivingStatus.PartialReceived;
-}
-
-function isPurchaseOrderComplete(status) {
-    return status === PurchaseOrderStatus.Done;
-}
-
-function isPurchaseOrderCanceled(status) {
-    return status === PurchaseOrderStatus.Canceled;
-}
-
-function isReceivingCanceled(status) {
-    return status === ReceivingStatus.Canceled;
-}
-
-module.exports = {
-    PurchaseOrderStatus,
-    ReceivingStatus,
-    PurchaseOrderStatusLabels,
-    ReceivingStatusLabels,
-    getPurchaseOrderStatusLabel,
-    getReceivingStatusLabel,
-    isReceivingComplete,
-    isPurchaseOrderComplete,
-    isPurchaseOrderCanceled,
-    isReceivingCanceled
-}; 

inventory-server/src/utils/csvImporter.js

@@ -1,63 +0,0 @@
-const fs = require('fs');
-const { parse } = require('csv-parse');
-const { v4: uuidv4 } = require('uuid');
-
-async function importProductsFromCSV(filePath, pool) {
-  return new Promise((resolve, reject) => {
-    const products = [];
-    
-    fs.createReadStream(filePath)
-      .pipe(parse({
-        columns: true,
-        skip_empty_lines: true
-      }))
-      .on('data', async (row) => {
-        products.push({
-          id: uuidv4(),
-          sku: row.sku,
-          name: row.name,
-          description: row.description || null,
-          category: row.category || null
-        });
-      })
-      .on('end', async () => {
-        try {
-          const connection = await pool.getConnection();
-          
-          try {
-            await connection.beginTransaction();
-            
-            for (const product of products) {
-              await connection.query(
-                'INSERT INTO products (id, sku, name, description, category) VALUES (?, ?, ?, ?, ?)',
-                [product.id, product.sku, product.name, product.description, product.category]
-              );
-              
-              // Initialize inventory level for the product
-              await connection.query(
-                'INSERT INTO inventory_levels (id, product_id, quantity) VALUES (?, ?, 0)',
-                [uuidv4(), product.id]
-              );
-            }
-            
-            await connection.commit();
-            resolve({ imported: products.length });
-          } catch (error) {
-            await connection.rollback();
-            reject(error);
-          } finally {
-            connection.release();
-          }
-        } catch (error) {
-          reject(error);
-        }
-      })
-      .on('error', (error) => {
-        reject(error);
-      });
-  });
-}
-
-module.exports = {
-  importProductsFromCSV
-}; 

inventory-server/src/utils/db.js

@@ -1,21 +0,0 @@
-const { Pool } = require('pg');
-
-let pool;
-
-function initPool(config) {
-  pool = new Pool(config);
-  return pool;
-}
-
-async function getConnection() {
-  if (!pool) {
-    throw new Error('Database pool not initialized');
-  }
-  return pool.connect();
-}
-
-module.exports = {
-  initPool,
-  getConnection,
-  getPool: () => pool
-}; 

inventory/index.html

@@ -2,9 +2,12 @@
 <html lang="en">
   <head>
     <meta charset="UTF-8" />
-    <link rel="icon" type="image/svg+xml" href="/box.svg" />
+    <link rel="icon" type="image/x-icon" href="/cherrybottom.ico" />
+    <link rel="preconnect" href="https://fonts.googleapis.com">
+    <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+    <link href="https://fonts.googleapis.com/css2?family=Inter:wght@100..900&display=swap" rel="stylesheet">
     <meta name="viewport" content="width=device-width, initial-scale=1.0" />
-    <title>Inventory Manager</title>
+    <title>A Cherry On Bottom</title>
   </head>
   <body>
     <div id="root"></div>

inventory/package.json

@@ -6,8 +6,10 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc -b && vite build",
+    "build:deploy": "tsc -b && COPY_BUILD=true DEPLOY_TARGET=netcup DEPLOY_PATH=/var/www/html/inventory/frontend vite build",
     "lint": "eslint .",
-    "preview": "vite preview"
+    "preview": "vite preview",
+    "mount": "../mountremote.command"
   },
   "dependencies": {
     "@dnd-kit/core": "^6.3.1",
@@ -30,12 +32,12 @@
     "@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.2",
+    "@radix-ui/react-slot": "^1.2.4",
     "@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-toggle": "^1.1.10",
+    "@radix-ui/react-toggle-group": "^1.1.11",
     "@radix-ui/react-tooltip": "^1.1.6",
     "@shadcn/ui": "^0.0.4",
     "@tabler/icons-react": "^3.28.1",
@@ -53,16 +55,21 @@
     "cmdk": "^1.0.0",
     "date-fns": "^3.6.0",
     "diff": "^7.0.0",
+    "embla-carousel-react": "^8.6.0",
     "framer-motion": "^12.4.4",
+    "immer": "^11.1.3",
+    "input-otp": "^1.4.1",
     "js-levenshtein": "^1.1.6",
     "lodash": "^4.17.21",
     "lucide-react": "^0.469.0",
+    "luxon": "^3.5.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-debounce-input": "^3.3.0",
     "react-dom": "^18.3.1",
     "react-dropzone": "^14.3.5",
     "react-hook-form": "^7.54.2",
@@ -76,12 +83,14 @@
     "uuid": "^11.0.5",
     "vaul": "^1.1.2",
     "xlsx": "^0.18.5",
-    "zod": "^3.24.2"
+    "zod": "^3.24.2",
+    "zustand": "^5.0.2"
   },
   "devDependencies": {
     "@eslint/js": "^9.17.0",
     "@types/fs-extra": "^11.0.4",
     "@types/lodash": "^4.17.15",
+    "@types/luxon": "^3.7.1",
     "@types/node": "^22.10.5",
     "@types/react": "^18.3.18",
     "@types/react-dom": "^18.3.5",

inventory/public/box.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24"><g fill="none" stroke="currentColor" stroke-linecap="round" stroke-linejoin="round" stroke-width="2"><path d="M21 8a2 2 0 0 0-1-1.73l-7-4a2 2 0 0 0-2 0l-7 4A2 2 0 0 0 3 8v8a2 2 0 0 0 1 1.73l7 4a2 2 0 0 0 2 0l7-4A2 2 0 0 0 21 16Z"/><path d="m3.3 7l8.7 5l8.7-5M12 22V12"/></g></svg>

inventory/src/App.css

@@ -1,42 +1,3 @@
 #root {
-  max-width: 1800px;
-  margin: 0 auto;
-  padding: 2rem;
-  text-align: center;
-}
-
-.logo {
-  height: 6em;
-  padding: 1.5em;
-  will-change: filter;
-  transition: filter 300ms;
-}
-.logo:hover {
-  filter: drop-shadow(0 0 2em #646cffaa);
-}
-.logo.react:hover {
-  filter: drop-shadow(0 0 2em #61dafbaa);
-}
-
-@keyframes logo-spin {
-  from {
-    transform: rotate(0deg);
-  }
-  to {
-    transform: rotate(360deg);
-  }
-}
-
-@media (prefers-reduced-motion: no-preference) {
-  a:nth-of-type(2) .logo {
-    animation: logo-spin infinite 20s linear;
-  }
-}
-
-.card {
-  padding: 2em;
-}
-
-.read-the-docs {
-  color: #888;
-}
+  font-family: 'Inter', sans-serif;
+}

inventory/src/App.tsx

@@ -1,23 +1,47 @@
 import { Routes, Route, useNavigate, Navigate, useLocation } from 'react-router-dom';
 import { MainLayout } from './components/layout/MainLayout';
 import { QueryClient, QueryClientProvider } from '@tanstack/react-query';
-import { Products } from './pages/Products';
-import { Dashboard } from './pages/Dashboard';
-import { Settings } from './pages/Settings';
-import { Analytics } from './pages/Analytics';
 import { Toaster } from '@/components/ui/sonner';
-import PurchaseOrders from './pages/PurchaseOrders';
-import { Login } from './pages/Login';
-import { useEffect } from 'react';
+import { useEffect, Suspense, lazy } from 'react';
 import config from './config';
 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 { AuthProvider } from './contexts/AuthContext';
 import { Protected } from './components/auth/Protected';
 import { FirstAccessiblePage } from './components/auth/FirstAccessiblePage';
+import { PageLoading } from '@/components/ui/page-loading';
+
+// Always loaded components (Login and Settings stay in main bundle)
+import { Settings } from './pages/Settings';  
+import { Login } from './pages/Login';
+
+// Lazy load the 4 main chunks you wanted:
+
+// 1. Core inventory app - loaded as one chunk when any inventory page is accessed
+const Overview = lazy(() => import('./pages/Overview'));
+const Products = lazy(() => import('./pages/Products').then(module => ({ default: module.Products })));
+const Analytics = lazy(() => import('./pages/Analytics').then(module => ({ default: module.Analytics })));
+const Forecasting = lazy(() => import('./pages/Forecasting'));
+const DiscountSimulator = lazy(() => import('./pages/DiscountSimulator'));
+const HtsLookup = lazy(() => import('./pages/HtsLookup'));
+const Vendors = lazy(() => import('./pages/Vendors'));
+const Categories = lazy(() => import('./pages/Categories'));  
+const Brands = lazy(() => import('./pages/Brands'));
+const PurchaseOrders = lazy(() => import('./pages/PurchaseOrders'));
+const BlackFridayDashboard = lazy(() => import('./pages/BlackFridayDashboard'));
+const Newsletter = lazy(() => import('./pages/Newsletter'));
+
+// 2. Dashboard app - separate chunk
+const Dashboard = lazy(() => import('./pages/Dashboard'));
+const SmallDashboard = lazy(() => import('./pages/SmallDashboard'));
+
+// 3. Product import - separate chunk
+const Import = lazy(() => import('./pages/Import').then(module => ({ default: module.Import })));
+
+// Product editor
+const ProductEditor = lazy(() => import('./pages/ProductEditor'));
+
+// 4. Chat archive - separate chunk
+const Chat = lazy(() => import('./pages/Chat').then(module => ({ default: module.Chat })));
 
 const queryClient = new QueryClient();
 
@@ -72,62 +96,151 @@ function App() {
       <AuthProvider>
         <Toaster richColors position="top-center" />
         <Routes>
+          {/* Always loaded routes */}
           <Route path="/login" element={<Login />} />
+          <Route path="/small" element={
+            <Suspense fallback={<PageLoading />}>
+              <SmallDashboard />
+            </Suspense>
+          } />
           <Route element={
             <RequireAuth>
               <MainLayout />
             </RequireAuth>
           }>
-            <Route index element={
-              <Protected page="dashboard" fallback={<FirstAccessiblePage />}>
-                <Dashboard />
-              </Protected>
-            } />
-            <Route path="/" element={
-              <Protected page="dashboard">
-                <Dashboard />
+            {/* Core inventory app routes - will be lazy loaded */}
+            {/* Default route now prioritizes dashboard, then other pages */}
+            <Route index element={<FirstAccessiblePage />} />
+            <Route path="/overview" element={
+              <Protected page="overview">
+                <Suspense fallback={<PageLoading />}>
+                  <Overview />
+                </Suspense>
               </Protected>
             } />
             <Route path="/products" element={
               <Protected page="products">
-                <Products />
-              </Protected>
-            } />
-            <Route path="/import" element={
-              <Protected page="import">
-                <Import />
+                <Suspense fallback={<PageLoading />}>
+                  <Products />
+                </Suspense>
               </Protected>
             } />
             <Route path="/categories" element={
               <Protected page="categories">
-                <Categories />
+                <Suspense fallback={<PageLoading />}>
+                  <Categories />
+                </Suspense>
               </Protected>
             } />
             <Route path="/vendors" element={
               <Protected page="vendors">
-                <Vendors />
+                <Suspense fallback={<PageLoading />}>
+                  <Vendors />
+                </Suspense>
+              </Protected>
+            } />
+            <Route path="/brands" element={
+              <Protected page="brands">
+                <Suspense fallback={<PageLoading />}>
+                  <Brands />
+                </Suspense>
               </Protected>
             } />
             <Route path="/purchase-orders" element={
               <Protected page="purchase_orders">
-                <PurchaseOrders />
+                <Suspense fallback={<PageLoading />}>
+                  <PurchaseOrders />
+                </Suspense>
               </Protected>
             } />
             <Route path="/analytics" element={
               <Protected page="analytics">
-                <Analytics />
+                <Suspense fallback={<PageLoading />}>
+                  <Analytics />
+                </Suspense>
               </Protected>
             } />
+            <Route path="/discount-simulator" element={
+              <Protected page="discount_simulator">
+                <Suspense fallback={<PageLoading />}>
+                  <DiscountSimulator />
+                </Suspense>
+              </Protected>
+            } />
+            <Route path="/hts-lookup" element={
+              <Protected page="hts_lookup">
+                <Suspense fallback={<PageLoading />}>
+                  <HtsLookup />
+                </Suspense>
+              </Protected>
+            } />
+            <Route path="/forecasting" element={
+              <Protected page="forecasting">
+                <Suspense fallback={<PageLoading />}>
+                  <Forecasting />
+                </Suspense>
+              </Protected>
+            } />
+            
+            {/* Always loaded settings */}
             <Route path="/settings" element={
               <Protected page="settings">
                 <Settings />
               </Protected>
             } />
-            <Route path="/forecasting" element={
-              <Protected page="forecasting">
-                <Forecasting />
+            
+            {/* Product editor */}
+            <Route path="/product-editor" element={
+              <Protected page="product_editor">
+                <Suspense fallback={<PageLoading />}>
+                  <ProductEditor />
+                </Suspense>
               </Protected>
             } />
+
+            {/* Product import - separate chunk */}
+            <Route path="/import" element={
+              <Protected page="import">
+                <Suspense fallback={<PageLoading />}>
+                  <Import />
+                </Suspense>
+              </Protected>
+            } />
+            
+            {/* Chat archive - separate chunk */}
+            <Route path="/chat" element={
+              <Protected page="chat">
+                <Suspense fallback={<PageLoading />}>
+                  <Chat />
+                </Suspense>
+              </Protected>
+            } />
+            
+            {/* Newsletter recommendations */}
+            <Route path="/newsletter" element={
+              <Protected page="newsletter">
+                <Suspense fallback={<PageLoading />}>
+                  <Newsletter />
+                </Suspense>
+              </Protected>
+            } />
+
+            {/* Dashboard app - separate chunk */}
+            <Route path="/dashboard" element={
+              <Protected page="dashboard">
+                <Suspense fallback={<PageLoading />}>
+                  <Dashboard />
+                </Suspense>
+              </Protected>
+            } />
+            <Route path="/dashboard/black-friday" element={
+              <Protected page="black_friday_dashboard">
+                <Suspense fallback={<PageLoading />}>
+                  <BlackFridayDashboard />
+                </Suspense>
+              </Protected>
+            } />
+            
             <Route path="*" element={<Navigate to="/" replace />} />
           </Route>
         </Routes>
@@ -137,4 +250,3 @@ function App() {
 }
 
 export default App;
-

inventory/src/components/ai/AiDescriptionCompare.tsx

@@ -0,0 +1,234 @@
+/**
+ * AiDescriptionCompare
+ *
+ * Shared side-by-side description editor for AI validation results.
+ * Shows the current description next to the AI-suggested version,
+ * both editable, with issues list and accept/dismiss actions.
+ *
+ * Layout uses a ResizeObserver to measure the right-side header+issues
+ * area and mirrors that height as a spacer on the left so both
+ * textareas start at the same vertical position. Textareas auto-resize
+ * to fit their content; the parent container controls overflow.
+ *
+ * Used by:
+ * - MultilineInput (inside a Popover, in the import validation table)
+ * - ProductEditForm (inside a Dialog, in the product editor)
+ */
+
+import { useState, useEffect, useRef, useCallback } from "react";
+import { Textarea } from "@/components/ui/textarea";
+import { Button } from "@/components/ui/button";
+import { Sparkles, AlertCircle, Check } from "lucide-react";
+import { cn } from "@/lib/utils";
+
+export interface AiDescriptionCompareProps {
+  currentValue: string;
+  onCurrentChange: (value: string) => void;
+  suggestion: string;
+  issues: string[];
+  onAccept: (editedSuggestion: string) => void;
+  onDismiss: () => void;
+  productName?: string;
+  className?: string;
+}
+
+export function AiDescriptionCompare({
+  currentValue,
+  onCurrentChange,
+  suggestion,
+  issues,
+  onAccept,
+  onDismiss,
+  productName,
+  className,
+}: AiDescriptionCompareProps) {
+  const [editedSuggestion, setEditedSuggestion] = useState(suggestion);
+  const [aiHeaderHeight, setAiHeaderHeight] = useState(0);
+  const aiHeaderRef = useRef<HTMLDivElement>(null);
+  const mainTextareaRef = useRef<HTMLTextAreaElement>(null);
+  const suggestionTextareaRef = useRef<HTMLTextAreaElement>(null);
+
+  // Reset edited suggestion when the suggestion prop changes
+  useEffect(() => {
+    setEditedSuggestion(suggestion);
+  }, [suggestion]);
+
+  // Measure right-side header+issues area for left-side spacer alignment.
+  // Wrapped in rAF because Radix portals mount asynchronously — the ref
+  // is null on the first synchronous run.
+  useEffect(() => {
+    let observer: ResizeObserver | null = null;
+    const rafId = requestAnimationFrame(() => {
+      const el = aiHeaderRef.current;
+      if (!el) return;
+      observer = new ResizeObserver(([entry]) => {
+        // Subtract 8px to compensate for the left column's py-2 top padding,
+        // so both "Current Description" and "Suggested" labels align vertically.
+        setAiHeaderHeight(Math.max(0, entry.contentRect.height - 8));
+      });
+      observer.observe(el);
+    });
+    return () => {
+      cancelAnimationFrame(rafId);
+      observer?.disconnect();
+    };
+  }, []);
+
+  // Auto-resize both textareas to fit content, then equalize their heights
+  // on desktop so tops and bottoms align exactly.
+  const syncTextareaHeights = useCallback(() => {
+    const main = mainTextareaRef.current;
+    const suggestion = suggestionTextareaRef.current;
+    if (!main && !suggestion) return;
+
+    // Reset to auto to measure natural content height
+    if (main) main.style.height = "auto";
+    if (suggestion) suggestion.style.height = "auto";
+
+    const mainH = main?.scrollHeight ?? 0;
+    const suggestionH = suggestion?.scrollHeight ?? 0;
+
+    // On desktop (lg), equalize so both textareas are the same height
+    const isDesktop = window.matchMedia("(min-width: 1024px)").matches;
+    const targetH = isDesktop ? Math.max(mainH, suggestionH) : 0;
+
+    if (main) main.style.height = `${targetH || mainH}px`;
+    if (suggestion) suggestion.style.height = `${targetH || suggestionH}px`;
+  }, []);
+
+  // Sync heights on mount and when content changes.
+  // Retry after a short delay to handle dialog/popover entry animations
+  // where the DOM isn't fully laid out on the first frame.
+  useEffect(() => {
+    requestAnimationFrame(syncTextareaHeights);
+    const timer = setTimeout(syncTextareaHeights, 200);
+    return () => clearTimeout(timer);
+  }, [currentValue, editedSuggestion, syncTextareaHeights]);
+
+  return (
+    <div className={cn("flex flex-col lg:flex-row items-stretch", className)}>
+      {/* Left: current description */}
+      <div className="flex flex-col min-h-0 w-full lg:w-1/2">
+        <div className="px-3 py-2 bg-accent flex flex-col flex-1 min-h-0">
+          {/* Product name - shown inline on mobile */}
+          {productName && (
+            <div className="flex-shrink-0 flex flex-col lg:hidden px-1 mb-2">
+              <div className="text-sm font-medium text-foreground mb-1">
+                Editing description for:
+              </div>
+              <div className="text-md font-semibold text-foreground">
+                {productName}
+              </div>
+            </div>
+          )}
+          {/* Desktop spacer matching the right-side header+issues height */}
+          {aiHeaderHeight > 0 && (
+            <div
+              className="flex-shrink-0 hidden lg:flex items-start"
+              style={{ height: aiHeaderHeight }}
+            >
+              {productName && (
+                <div className="flex flex-col">
+                  <div className="text-sm font-medium text-foreground px-1 mb-1">
+                    Editing description for:
+                  </div>
+                  <div className="text-md font-semibold text-foreground px-1">
+                    {productName}
+                  </div>
+                </div>
+              )}
+            </div>
+          )}
+          <div className="text-sm mb-1 font-medium flex items-center gap-2 flex-shrink-0">
+            Current Description:
+          </div>
+          <Textarea
+            ref={mainTextareaRef}
+            value={currentValue}
+            onChange={(e) => {
+              onCurrentChange(e.target.value);
+              syncTextareaHeights();
+            }}
+            className="overflow-y-auto overscroll-contain text-sm resize-y bg-white min-h-[120px]"
+          />
+          {/* Footer spacer matching the action buttons height on the right */}
+          <div className="h-[43px] flex-shrink-0 hidden lg:block" />
+        </div>
+      </div>
+
+      {/* Right: AI suggestion */}
+      <div className="bg-purple-50/80 dark:bg-purple-950/30 flex flex-col w-full lg:w-1/2">
+        {/* Measured header + issues area (height mirrored as spacer on the left) */}
+        <div ref={aiHeaderRef} className="flex-shrink-0">
+          {/* Header */}
+          <div className="w-full flex items-center justify-between px-3 py-2">
+            <div className="flex items-center gap-2">
+              <Sparkles className="h-3.5 w-3.5 text-purple-500" />
+              <span className="text-xs font-medium text-purple-600 dark:text-purple-400">
+                AI Suggestion
+              </span>
+              <span className="text-xs text-purple-500 dark:text-purple-400">
+                ({issues.length} {issues.length === 1 ? "issue" : "issues"})
+              </span>
+            </div>
+          </div>
+
+          {/* Issues list */}
+          {issues.length > 0 && (
+            <div className="flex flex-col gap-1 px-3 pb-3">
+              {issues.map((issue, index) => (
+                <div
+                  key={index}
+                  className="flex items-start gap-1.5 text-xs text-purple-600 dark:text-purple-400"
+                >
+                  <AlertCircle className="h-3 w-3 mt-0.5 flex-shrink-0 text-purple-400" />
+                  <span>{issue}</span>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+
+        {/* Content */}
+        <div className="px-3 pb-3 flex flex-col flex-1 gap-3">
+          {/* Editable suggestion */}
+          <div className="flex flex-col flex-1">
+            <div className="text-sm text-purple-500 dark:text-purple-400 mb-1 font-medium flex-shrink-0">
+              Suggested (editable):
+            </div>
+            <Textarea
+              ref={suggestionTextareaRef}
+              value={editedSuggestion}
+              onChange={(e) => {
+                setEditedSuggestion(e.target.value);
+                syncTextareaHeights();
+              }}
+              className="overflow-y-auto overscroll-contain text-sm bg-white dark:bg-black/20 border-purple-200 dark:border-purple-700 focus-visible:ring-purple-400 resize-y min-h-[120px]"
+            />
+          </div>
+
+          {/* Actions */}
+          <div className="flex items-center gap-2 flex-shrink-0">
+            <Button
+              size="sm"
+              variant="outline"
+              className="h-7 px-3 text-xs bg-white border-green-300 text-green-700 hover:bg-green-50 hover:border-green-400 dark:bg-green-950/30 dark:border-green-700 dark:text-green-400"
+              onClick={() => onAccept(editedSuggestion)}
+            >
+              <Check className="h-3 w-3 mr-1" />
+              Replace With Suggestion
+            </Button>
+            <Button
+              size="sm"
+              variant="ghost"
+              className="h-7 px-3 text-xs text-gray-500 hover:text-gray-700 dark:text-gray-400"
+              onClick={onDismiss}
+            >
+              Ignore
+            </Button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+}

inventory/src/components/analytics/AgingSellThrough.tsx

@@ -0,0 +1,143 @@
+import { useQuery } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  ResponsiveContainer,
+  BarChart,
+  Bar,
+  XAxis,
+  YAxis,
+  Tooltip,
+  CartesianGrid,
+  Cell,
+} from 'recharts';
+import config from '../../config';
+import { METRIC_COLORS } from '@/lib/dashboard/designTokens';
+import { formatCurrency } from '@/utils/formatCurrency';
+
+interface AgingCohort {
+  cohort: string;
+  productCount: number;
+  avgSellThrough: number;
+  stockCost: number;
+  revenue: number;
+  unitsSold: number;
+}
+
+function getSellThroughColor(rate: number): string {
+  if (rate >= 30) return METRIC_COLORS.revenue;
+  if (rate >= 15) return METRIC_COLORS.orders;
+  if (rate >= 5) return METRIC_COLORS.comparison;
+  return '#ef4444';
+}
+
+export function AgingSellThrough() {
+  const { data, isLoading, isError } = useQuery<AgingCohort[]>({
+    queryKey: ['aging-sell-through'],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/analytics/aging`);
+      if (!response.ok) throw new Error('Failed to fetch aging data');
+      return response.json();
+    },
+  });
+
+  if (isError) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>Aging & Sell-Through</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[350px] flex items-center justify-center">
+            <p className="text-sm text-destructive">Failed to load aging data</p>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (isLoading || !data) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>Aging & Sell-Through</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[350px] flex items-center justify-center">
+            <div className="animate-pulse text-muted-foreground">Loading aging data...</div>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  return (
+    <div className="grid gap-4 md:grid-cols-2">
+      <Card>
+        <CardHeader>
+          <CardTitle>Sell-Through Rate by Age</CardTitle>
+          <p className="text-xs text-muted-foreground">
+            Avg 30-day sell-through % for products by age since first received
+          </p>
+        </CardHeader>
+        <CardContent>
+          <ResponsiveContainer width="100%" height={300}>
+            <BarChart data={data}>
+              <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+              <XAxis dataKey="cohort" tick={{ fontSize: 11 }} />
+              <YAxis tickFormatter={(v) => `${v}%`} tick={{ fontSize: 11 }} />
+              <Tooltip
+                content={({ active, payload }) => {
+                  if (!active || !payload?.length) return null;
+                  const d = payload[0].payload as AgingCohort;
+                  return (
+                    <div className="rounded-lg border bg-background p-3 shadow-md text-sm">
+                      <p className="font-medium mb-1">Age: {d.cohort}</p>
+                      <p>Sell-through: <span className="font-medium">{d.avgSellThrough}%</span></p>
+                      <p>{d.productCount.toLocaleString()} products</p>
+                      <p>Stock value: {formatCurrency(d.stockCost)}</p>
+                    </div>
+                  );
+                }}
+              />
+              <Bar dataKey="avgSellThrough" name="Sell-Through %" radius={[4, 4, 0, 0]}>
+                {data.map((entry, i) => (
+                  <Cell key={i} fill={getSellThroughColor(entry.avgSellThrough)} />
+                ))}
+              </Bar>
+            </BarChart>
+          </ResponsiveContainer>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Capital Tied Up by Age</CardTitle>
+          <p className="text-xs text-muted-foreground">
+            Stock investment distribution across product age cohorts
+          </p>
+        </CardHeader>
+        <CardContent>
+          <ResponsiveContainer width="100%" height={300}>
+            <BarChart data={data}>
+              <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+              <XAxis dataKey="cohort" tick={{ fontSize: 11 }} />
+              <YAxis tickFormatter={formatCurrency} tick={{ fontSize: 11 }} />
+              <Tooltip
+                content={({ active, payload }) => {
+                  if (!active || !payload?.length) return null;
+                  const d = payload[0].payload as AgingCohort;
+                  return (
+                    <div className="rounded-lg border bg-background p-3 shadow-md text-sm">
+                      <p className="font-medium mb-1">Age: {d.cohort}</p>
+                      <p>Stock cost: {formatCurrency(d.stockCost)}</p>
+                      <p>Revenue (30d): {formatCurrency(d.revenue)}</p>
+                      <p>{d.productCount.toLocaleString()} products</p>
+                      <p>{d.unitsSold.toLocaleString()} units sold (30d)</p>
+                    </div>
+                  );
+                }}
+              />
+              <Bar dataKey="stockCost" name="Stock Investment" fill={METRIC_COLORS.aov} radius={[4, 4, 0, 0]} />
+            </BarChart>
+          </ResponsiveContainer>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

inventory/src/components/analytics/CapitalEfficiency.tsx

@@ -0,0 +1,201 @@
+import { useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  ResponsiveContainer,
+  BarChart,
+  Bar,
+  XAxis,
+  YAxis,
+  Tooltip,
+  CartesianGrid,
+  ScatterChart,
+  Scatter,
+  ZAxis,
+  Cell,
+  ReferenceLine,
+} from 'recharts';
+import config from '../../config';
+import { METRIC_COLORS } from '@/lib/dashboard/designTokens';
+import { formatCurrency } from '@/utils/formatCurrency';
+
+interface BrandData {
+  brand: string;
+  productCount: number;
+  stockCost: number;
+  profit30d: number;
+  revenue30d: number;
+  gmroi: number;
+}
+
+interface EfficiencyData {
+  brands: BrandData[];
+}
+
+function getGmroiColor(gmroi: number): string {
+  if (gmroi >= 3) return METRIC_COLORS.revenue;      // emerald — strong
+  if (gmroi >= 1) return METRIC_COLORS.comparison;   // amber — acceptable
+  return '#ef4444';                                    // red — poor
+}
+
+type GmroiView = 'top' | 'bottom';
+
+export function CapitalEfficiency() {
+  const [gmroiView, setGmroiView] = useState<GmroiView>('top');
+  const { data, isLoading, isError } = useQuery<EfficiencyData>({
+    queryKey: ['capital-efficiency'],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/analytics/efficiency`);
+      if (!response.ok) throw new Error('Failed to fetch capital efficiency');
+      return response.json();
+    },
+  });
+
+  if (isError) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>Capital Efficiency</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[350px] flex items-center justify-center">
+            <p className="text-sm text-destructive">Failed to load efficiency data</p>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (isLoading || !data) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>Capital Efficiency</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[350px] flex items-center justify-center">
+            <div className="animate-pulse text-muted-foreground">Loading efficiency...</div>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  // Top or bottom 15 by GMROI for bar chart
+  const sortedGmroi = gmroiView === 'top'
+    ? [...data.brands].sort((a, b) => b.gmroi - a.gmroi).slice(0, 15)
+    : [...data.brands].sort((a, b) => a.gmroi - b.gmroi).slice(0, 15);
+
+  return (
+    <div className="grid gap-4 md:grid-cols-2">
+      <Card>
+        <CardHeader>
+          <div className="flex items-center justify-between">
+            <div>
+              <CardTitle>GMROI by Brand</CardTitle>
+              <p className="text-xs text-muted-foreground">
+                Annualized gross margin return on investment (top 30 brands by stock value)
+              </p>
+            </div>
+            <div className="flex gap-1">
+              {(['top', 'bottom'] as GmroiView[]).map((v) => (
+                <button
+                  key={v}
+                  onClick={() => setGmroiView(v)}
+                  className={`px-3 py-1 text-xs rounded-md transition-colors ${
+                    gmroiView === v
+                      ? 'bg-primary text-primary-foreground'
+                      : 'bg-muted text-muted-foreground hover:bg-muted/80'
+                  }`}
+                >
+                  {v === 'top' ? 'Best' : 'Worst'}
+                </button>
+              ))}
+            </div>
+          </div>
+        </CardHeader>
+        <CardContent>
+          <ResponsiveContainer width="100%" height={400}>
+            <BarChart data={sortedGmroi} layout="vertical">
+              <CartesianGrid strokeDasharray="3 3" className="stroke-muted" horizontal={false} />
+              <XAxis type="number" tick={{ fontSize: 11 }} />
+              <YAxis
+                type="category"
+                dataKey="brand"
+                width={140}
+                tick={{ fontSize: 11 }}
+              />
+              <Tooltip
+                content={({ active, payload }) => {
+                  if (!active || !payload?.length) return null;
+                  const d = payload[0].payload as BrandData;
+                  return (
+                    <div className="rounded-lg border bg-background p-3 shadow-md text-sm">
+                      <p className="font-medium mb-1">{d.brand}</p>
+                      <p>GMROI: <span className="font-medium">{d.gmroi.toFixed(2)}</span></p>
+                      <p>Stock Investment: {formatCurrency(d.stockCost)}</p>
+                      <p>Profit (30d): {formatCurrency(d.profit30d)}</p>
+                      <p>Revenue (30d): {formatCurrency(d.revenue30d)}</p>
+                      <p>{d.productCount} products</p>
+                    </div>
+                  );
+                }}
+              />
+              <ReferenceLine x={3} stroke="#9ca3af" strokeDasharray="3 3" label={{ value: '3.0', position: 'top', fontSize: 10 }} />
+              <Bar dataKey="gmroi" name="GMROI" radius={[0, 4, 4, 0]}>
+                {sortedGmroi.map((entry, i) => (
+                  <Cell key={i} fill={getGmroiColor(entry.gmroi)} />
+                ))}
+              </Bar>
+            </BarChart>
+          </ResponsiveContainer>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Investment vs Profit by Brand</CardTitle>
+          <p className="text-xs text-muted-foreground">
+            Bubble size = product count. Ideal: high profit, low stock cost.
+          </p>
+        </CardHeader>
+        <CardContent>
+          <ResponsiveContainer width="100%" height={400}>
+            <ScatterChart>
+              <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+              <XAxis
+                dataKey="stockCost"
+                name="Stock Investment"
+                tickFormatter={formatCurrency}
+                tick={{ fontSize: 11 }}
+                type="number"
+                label={{ value: 'Stock Investment', position: 'insideBottom', offset: -5, fontSize: 12, fill: '#888' }}
+              />
+              <YAxis
+                dataKey="profit30d"
+                name="Profit (30d)"
+                tickFormatter={formatCurrency}
+                tick={{ fontSize: 11 }}
+                type="number"
+                label={{ value: 'Profit (30d)', angle: -90, position: 'insideLeft', offset: 10, fontSize: 12, fill: '#888' }}
+              />
+              <ZAxis dataKey="productCount" range={[40, 400]} name="Products" />
+              <Tooltip
+                content={({ active, payload }) => {
+                  if (!active || !payload?.length) return null;
+                  const d = payload[0].payload as BrandData;
+                  return (
+                    <div className="rounded-lg border bg-background p-3 shadow-md text-sm">
+                      <p className="font-medium mb-1">{d.brand}</p>
+                      <p>Stock Investment: {formatCurrency(d.stockCost)}</p>
+                      <p>Profit (30d): {formatCurrency(d.profit30d)}</p>
+                      <p>Revenue (30d): {formatCurrency(d.revenue30d)}</p>
+                      <p>{d.productCount} products</p>
+                    </div>
+                  );
+                }}
+              />
+              <Scatter data={data.brands} fill={METRIC_COLORS.orders} fillOpacity={0.6} />
+            </ScatterChart>
+          </ResponsiveContainer>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

inventory/src/components/analytics/CategoryPerformance.tsx

@@ -1,201 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
-import { ResponsiveContainer, BarChart, Bar, XAxis, YAxis, Tooltip, PieChart, Pie, Cell, Legend } from 'recharts';
-import config from '../../config';
-
-interface CategoryData {
-  performance: {
-    category: string;
-    categoryPath: string;  // Full hierarchy path
-    revenue: number;
-    profit: number;
-    growth: number;
-    productCount: number;
-  }[];
-  distribution: {
-    category: string;
-    categoryPath: string;  // Full hierarchy path
-    value: number;
-  }[];
-  trends: {
-    category: string;
-    categoryPath: string;  // Full hierarchy path
-    month: string;
-    sales: number;
-  }[];
-}
-
-const COLORS = ['#4ade80', '#60a5fa', '#f87171', '#fbbf24', '#a78bfa', '#f472b6'];
-
-export function CategoryPerformance() {
-  const { data, isLoading } = useQuery<CategoryData>({
-    queryKey: ['category-performance'],
-    queryFn: async () => {
-      const response = await fetch(`${config.apiUrl}/analytics/categories`);
-      if (!response.ok) {
-        throw new Error('Failed to fetch category performance');
-      }
-      const rawData = await response.json();
-      return {
-        performance: rawData.performance.map((item: any) => ({
-          ...item,
-          categoryPath: item.categoryPath || item.category,
-          revenue: Number(item.revenue) || 0,
-          profit: Number(item.profit) || 0,
-          growth: Number(item.growth) || 0,
-          productCount: Number(item.productCount) || 0
-        })),
-        distribution: rawData.distribution.map((item: any) => ({
-          ...item,
-          categoryPath: item.categoryPath || item.category,
-          value: Number(item.value) || 0
-        })),
-        trends: rawData.trends.map((item: any) => ({
-          ...item,
-          categoryPath: item.categoryPath || item.category,
-          sales: Number(item.sales) || 0
-        }))
-      };
-    },
-  });
-
-  if (isLoading || !data) {
-    return <div>Loading category performance...</div>;
-  }
-
-  const formatGrowth = (growth: number) => {
-    const value = growth >= 0 ? `+${growth.toFixed(1)}%` : `${growth.toFixed(1)}%`;
-    const color = growth >= 0 ? 'text-green-500' : 'text-red-500';
-    return <span className={color}>{value}</span>;
-  };
-
-  const getShortCategoryName = (path: string) => path.split(' > ').pop() || path;
-
-  return (
-    <div className="grid gap-4">
-      <div className="grid gap-4 md:grid-cols-2">
-        <Card>
-          <CardHeader>
-            <CardTitle>Category Revenue Distribution</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <ResponsiveContainer width="100%" height={300}>
-              <PieChart>
-                <Pie
-                  data={data.distribution}
-                  dataKey="value"
-                  nameKey="categoryPath"
-                  cx="50%"
-                  cy="50%"
-                  outerRadius={100}
-                  fill="#8884d8"
-                  label={({ categoryPath }) => getShortCategoryName(categoryPath)}
-                >
-                  {data.distribution.map((entry, index) => (
-                    <Cell 
-                      key={`${entry.category}-${entry.value}-${index}`}
-                      fill={COLORS[index % COLORS.length]} 
-                    />
-                  ))}
-                </Pie>
-                <Tooltip 
-                  formatter={(value: number, _: string, props: any) => [
-                    `$${value.toLocaleString()}`,
-                    <div key="tooltip">
-                      <div className="font-medium">Category Path:</div>
-                      <div className="text-sm text-muted-foreground">{props.payload.categoryPath}</div>
-                      <div className="mt-1">Revenue</div>
-                    </div>
-                  ]}
-                />
-                <Legend 
-                  formatter={(value) => getShortCategoryName(value)} 
-                  wrapperStyle={{ fontSize: '12px' }}
-                />
-              </PieChart>
-            </ResponsiveContainer>
-          </CardContent>
-        </Card>
-
-        <Card>
-          <CardHeader>
-            <CardTitle>Category Growth Rates</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <ResponsiveContainer width="100%" height={300}>
-              <BarChart data={data.performance}>
-                <XAxis 
-                  dataKey="categoryPath"
-                  tick={({ x, y, payload }) => (
-                    <g transform={`translate(${x},${y})`}>
-                      <text
-                        x={0}
-                        y={0}
-                        dy={16}
-                        textAnchor="end"
-                        fill="#888888"
-                        transform="rotate(-35)"
-                      >
-                        {getShortCategoryName(payload.value)}
-                      </text>
-                    </g>
-                  )}
-                />
-                <YAxis tickFormatter={(value) => `${value}%`} />
-                <Tooltip 
-                  formatter={(value: number, _: string, props: any) => [
-                    `${value.toFixed(1)}%`,
-                    <div key="tooltip">
-                      <div className="font-medium">Category Path:</div>
-                      <div className="text-sm text-muted-foreground">{props.payload.categoryPath}</div>
-                      <div className="mt-1">Growth Rate</div>
-                    </div>
-                  ]}
-                />
-                <Bar 
-                  dataKey="growth" 
-                  fill="#4ade80"
-                  name="Growth Rate"
-                />
-              </BarChart>
-            </ResponsiveContainer>
-          </CardContent>
-        </Card>
-      </div>
-
-      <Card>
-        <CardHeader>
-          <CardTitle>Category Performance Details</CardTitle>
-        </CardHeader>
-        <CardContent>
-          <div className="space-y-4">
-            {data.performance.map((category) => (
-              <div key={`${category.category}-${category.revenue}`} className="flex items-center">
-                <div className="flex-1">
-                  <div className="space-y-1">
-                    <p className="text-sm font-medium">{getShortCategoryName(category.categoryPath)}</p>
-                    <p className="text-xs text-muted-foreground">{category.categoryPath}</p>
-                  </div>
-                  <p className="text-sm text-muted-foreground mt-1">
-                    {category.productCount} products
-                  </p>
-                </div>
-                <div className="ml-4 text-right space-y-1">
-                  <p className="text-sm font-medium">
-                    ${category.revenue.toLocaleString()} revenue
-                  </p>
-                  <p className="text-sm text-muted-foreground">
-                    ${category.profit.toLocaleString()} profit
-                  </p>
-                  <p className="text-sm text-muted-foreground">
-                    Growth: {formatGrowth(category.growth)}
-                  </p>
-                </div>
-              </div>
-            ))}
-          </div>
-        </CardContent>
-      </Card>
-    </div>
-  );
-} 

inventory/src/components/analytics/DiscountImpact.tsx

@@ -0,0 +1,159 @@
+import { useQuery } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  ResponsiveContainer,
+  BarChart,
+  Bar,
+  XAxis,
+  YAxis,
+  Tooltip,
+  CartesianGrid,
+  Legend,
+} from 'recharts';
+import config from '../../config';
+import { METRIC_COLORS } from '@/lib/dashboard/designTokens';
+import { formatCurrency } from '@/utils/formatCurrency';
+
+interface DiscountRow {
+  abcClass: string;
+  discountBucket: string;
+  productCount: number;
+  avgSellThrough: number;
+  revenue: number;
+  discountAmount: number;
+  profit: number;
+}
+
+const CLASS_COLORS: Record<string, string> = {
+  A: METRIC_COLORS.revenue,
+  B: METRIC_COLORS.orders,
+  C: METRIC_COLORS.comparison,
+};
+
+export function DiscountImpact() {
+  const { data, isLoading, isError } = useQuery<DiscountRow[]>({
+    queryKey: ['discount-impact'],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/analytics/discounts`);
+      if (!response.ok) throw new Error('Failed to fetch discount data');
+      return response.json();
+    },
+  });
+
+  if (isError) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>Discount Impact</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[300px] flex items-center justify-center">
+            <p className="text-sm text-destructive">Failed to load discount data</p>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (isLoading || !data) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>Discount Impact</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[300px] flex items-center justify-center">
+            <div className="animate-pulse text-muted-foreground">Loading discount data...</div>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  // Pivot: for each discount bucket, show avg sell-through by ABC class
+  const buckets = ['No Discount', '1-10%', '11-20%', '21-30%', '30%+'];
+  const chartData = buckets.map(bucket => {
+    const row: Record<string, string | number> = { bucket };
+    ['A', 'B', 'C'].forEach(cls => {
+      const match = data.find(d => d.discountBucket === bucket && d.abcClass === cls);
+      row[`Class ${cls}`] = match?.avgSellThrough || 0;
+    });
+    return row;
+  });
+
+  // Summary by ABC class
+  const classSummary = ['A', 'B', 'C'].map(cls => {
+    const rows = data.filter(d => d.abcClass === cls);
+    return {
+      abcClass: cls,
+      totalProducts: rows.reduce((s, r) => s + r.productCount, 0),
+      totalDiscounts: rows.reduce((s, r) => s + r.discountAmount, 0),
+      totalRevenue: rows.reduce((s, r) => s + r.revenue, 0),
+      totalProfit: rows.reduce((s, r) => s + r.profit, 0),
+    };
+  });
+
+  return (
+    <div className="grid gap-4 md:grid-cols-2">
+      <Card>
+        <CardHeader>
+          <CardTitle>Sell-Through by Discount Level</CardTitle>
+          <p className="text-xs text-muted-foreground">
+            Avg 30-day sell-through % at each discount bracket, by ABC class
+          </p>
+        </CardHeader>
+        <CardContent>
+          <ResponsiveContainer width="100%" height={350}>
+            <BarChart data={chartData}>
+              <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+              <XAxis dataKey="bucket" tick={{ fontSize: 11 }} />
+              <YAxis tickFormatter={(v) => `${v}%`} tick={{ fontSize: 11 }} />
+              <Tooltip formatter={(value: number) => [`${value}%`]} />
+              <Legend />
+              <Bar dataKey="Class A" fill={CLASS_COLORS.A} radius={[2, 2, 0, 0]} />
+              <Bar dataKey="Class B" fill={CLASS_COLORS.B} radius={[2, 2, 0, 0]} />
+              <Bar dataKey="Class C" fill={CLASS_COLORS.C} radius={[2, 2, 0, 0]} />
+            </BarChart>
+          </ResponsiveContainer>
+        </CardContent>
+      </Card>
+
+      <Card>
+        <CardHeader>
+          <CardTitle>Discount Leakage by Class</CardTitle>
+          <p className="text-xs text-muted-foreground">
+            How much discount is given relative to revenue per ABC class
+          </p>
+        </CardHeader>
+        <CardContent>
+          <div className="rounded-md border">
+            <table className="w-full text-sm">
+              <thead>
+                <tr className="border-b bg-muted/50">
+                  <th className="px-4 py-2 text-left font-medium">Class</th>
+                  <th className="px-4 py-2 text-right font-medium">Products</th>
+                  <th className="px-4 py-2 text-right font-medium">Revenue</th>
+                  <th className="px-4 py-2 text-right font-medium">Discounts</th>
+                  <th className="px-4 py-2 text-right font-medium">Disc %</th>
+                  <th className="px-4 py-2 text-right font-medium">Profit</th>
+                </tr>
+              </thead>
+              <tbody>
+                {classSummary.map((row) => (
+                  <tr key={row.abcClass} className="border-b">
+                    <td className="px-4 py-2 font-medium">Class {row.abcClass}</td>
+                    <td className="px-4 py-2 text-right">{row.totalProducts.toLocaleString()}</td>
+                    <td className="px-4 py-2 text-right">{formatCurrency(row.totalRevenue)}</td>
+                    <td className="px-4 py-2 text-right">{formatCurrency(row.totalDiscounts)}</td>
+                    <td className="px-4 py-2 text-right">
+                      {row.totalRevenue > 0
+                        ? ((row.totalDiscounts / (row.totalRevenue + row.totalDiscounts)) * 100).toFixed(1)
+                        : '0'}%
+                    </td>
+                    <td className="px-4 py-2 text-right">{formatCurrency(row.totalProfit)}</td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

inventory/src/components/analytics/GrowthMomentum.tsx

@@ -0,0 +1,217 @@
+import { useQuery } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  ResponsiveContainer,
+  BarChart,
+  Bar,
+  XAxis,
+  YAxis,
+  Tooltip,
+  CartesianGrid,
+  Legend,
+} from 'recharts';
+import config from '../../config';
+import { METRIC_COLORS } from '@/lib/dashboard/designTokens';
+import { TrendingUp, TrendingDown, Plus, Archive } from 'lucide-react';
+import { formatCurrency } from '@/utils/formatCurrency';
+
+interface GrowthRow {
+  abcClass: string;
+  growthBucket: string;
+  productCount: number;
+  revenue: number;
+  stockCost: number;
+}
+
+interface GrowthSummary {
+  comparableCount: number;
+  growingCount: number;
+  decliningCount: number;
+  weightedAvgGrowth: number;
+  medianGrowth: number;
+}
+
+interface CatalogTurnover {
+  newProducts: number;
+  newProductRevenue: number;
+  discontinued: number;
+  discontinuedStockValue: number;
+}
+
+interface GrowthData {
+  byClass: GrowthRow[];
+  summary: GrowthSummary;
+  turnover: CatalogTurnover;
+}
+
+const GROWTH_COLORS: Record<string, string> = {
+  'Strong Growth (>50%)': METRIC_COLORS.revenue,
+  'Growing (0-50%)': '#34d399',
+  'Declining (0-50%)': METRIC_COLORS.comparison,
+  'Sharp Decline (>50%)': '#ef4444',
+};
+
+export function GrowthMomentum() {
+  const { data, isLoading, isError } = useQuery<GrowthData>({
+    queryKey: ['growth-momentum'],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/analytics/growth`);
+      if (!response.ok) throw new Error('Failed to fetch growth data');
+      return response.json();
+    },
+  });
+
+  if (isError) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>YoY Growth Momentum</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[300px] flex items-center justify-center">
+            <p className="text-sm text-destructive">Failed to load growth data</p>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (isLoading || !data) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>YoY Growth Momentum</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[300px] flex items-center justify-center">
+            <div className="animate-pulse text-muted-foreground">Loading growth data...</div>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  const { summary, turnover } = data;
+  const growingPct = summary.comparableCount > 0
+    ? ((summary.growingCount / summary.comparableCount) * 100).toFixed(0)
+    : '0';
+
+  // Pivot: for each ABC class, show product counts by growth bucket
+  const classes = ['A', 'B', 'C'];
+  const buckets = ['Strong Growth (>50%)', 'Growing (0-50%)', 'Declining (0-50%)', 'Sharp Decline (>50%)'];
+  const chartData = classes.map(cls => {
+    const row: Record<string, string | number> = { abcClass: `Class ${cls}` };
+    buckets.forEach(bucket => {
+      const match = data.byClass.find(d => d.abcClass === cls && d.growthBucket === bucket);
+      row[bucket] = match?.productCount || 0;
+    });
+    return row;
+  });
+
+  return (
+    <div className="space-y-4">
+      {/* Row 1: Comparable growth metrics */}
+      <div className="grid gap-4 md:grid-cols-4">
+        <Card>
+          <CardContent className="flex items-center gap-3 py-4">
+            <div className="rounded-full p-2 bg-green-500/10">
+              <TrendingUp className="h-4 w-4 text-green-500" />
+            </div>
+            <div>
+              <p className="text-sm font-medium">Comparable Growing</p>
+              <p className="text-xl font-bold">{growingPct}%</p>
+              <p className="text-xs text-muted-foreground">{summary.growingCount.toLocaleString()} of {summary.comparableCount.toLocaleString()} products</p>
+            </div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardContent className="flex items-center gap-3 py-4">
+            <div className="rounded-full p-2 bg-red-500/10">
+              <TrendingDown className="h-4 w-4 text-red-500" />
+            </div>
+            <div>
+              <p className="text-sm font-medium">Comparable Declining</p>
+              <p className="text-xl font-bold">{summary.decliningCount.toLocaleString()}</p>
+              <p className="text-xs text-muted-foreground">products with lower YoY sales</p>
+            </div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardContent className="py-4">
+            <p className="text-sm font-medium text-muted-foreground">Weighted Avg Growth</p>
+            <p className={`text-2xl font-bold ${summary.weightedAvgGrowth >= 0 ? 'text-green-500' : 'text-red-500'}`}>
+              {summary.weightedAvgGrowth > 0 ? '+' : ''}{summary.weightedAvgGrowth}%
+            </p>
+            <p className="text-xs text-muted-foreground">revenue-weighted</p>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardContent className="py-4">
+            <p className="text-sm font-medium text-muted-foreground">Median YoY Growth</p>
+            <p className={`text-2xl font-bold ${summary.medianGrowth >= 0 ? 'text-green-500' : 'text-red-500'}`}>
+              {summary.medianGrowth > 0 ? '+' : ''}{summary.medianGrowth}%
+            </p>
+            <p className="text-xs text-muted-foreground">typical product growth</p>
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* Row 2: Catalog turnover */}
+      <div className="grid gap-4 md:grid-cols-2">
+        <Card>
+          <CardContent className="flex items-center gap-3 py-4">
+            <div className="rounded-full p-2 bg-blue-500/10">
+              <Plus className="h-4 w-4 text-blue-500" />
+            </div>
+            <div>
+              <p className="text-sm font-medium">New Products (&lt;1yr)</p>
+              <p className="text-xl font-bold">{turnover.newProducts.toLocaleString()}</p>
+              <p className="text-xs text-muted-foreground">{formatCurrency(turnover.newProductRevenue)} revenue (30d)</p>
+            </div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardContent className="flex items-center gap-3 py-4">
+            <div className="rounded-full p-2 bg-amber-500/10">
+              <Archive className="h-4 w-4 text-amber-500" />
+            </div>
+            <div>
+              <p className="text-sm font-medium">Discontinued</p>
+              <p className="text-xl font-bold">{turnover.discontinued.toLocaleString()}</p>
+              <p className="text-xs text-muted-foreground">
+                {turnover.discontinuedStockValue > 0
+                  ? `${formatCurrency(turnover.discontinuedStockValue)} still in stock`
+                  : 'no remaining stock'}
+              </p>
+            </div>
+          </CardContent>
+        </Card>
+      </div>
+
+      {/* Chart: comparable products only */}
+      <Card>
+        <CardHeader>
+          <CardTitle>Comparable Growth by ABC Class</CardTitle>
+          <p className="text-xs text-muted-foreground">
+            Products selling in both this and last year's period — excludes new launches and discontinued
+          </p>
+        </CardHeader>
+        <CardContent>
+          <ResponsiveContainer width="100%" height={350}>
+            <BarChart data={chartData}>
+              <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+              <XAxis dataKey="abcClass" tick={{ fontSize: 12 }} />
+              <YAxis tick={{ fontSize: 11 }} label={{ value: 'Products', angle: -90, position: 'insideLeft', offset: -5, style: { fontSize: 11, fill: '#9ca3af' } }} />
+              <Tooltip />
+              <Legend wrapperStyle={{ fontSize: 11 }} />
+              {buckets.map(bucket => (
+                <Bar
+                  key={bucket}
+                  dataKey={bucket}
+                  stackId="growth"
+                  fill={GROWTH_COLORS[bucket]}
+                />
+              ))}
+            </BarChart>
+          </ResponsiveContainer>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}

inventory/src/components/analytics/InventoryFlow.tsx

@@ -0,0 +1,186 @@
+import { useState, useMemo } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  ResponsiveContainer,
+  Bar,
+  XAxis,
+  YAxis,
+  Tooltip,
+  CartesianGrid,
+  Line,
+  ComposedChart,
+  Legend,
+} from 'recharts';
+import config from '../../config';
+import { METRIC_COLORS } from '@/lib/dashboard/designTokens';
+import { formatCurrency } from '@/utils/formatCurrency';
+import { ArrowDownToLine, ArrowUpFromLine, TrendingUp } from 'lucide-react';
+
+interface FlowPoint {
+  date: string;
+  unitsReceived: number;
+  costReceived: number;
+  unitsSold: number;
+  cogsSold: number;
+}
+
+type Period = 30 | 90;
+
+function formatDate(dateStr: string, period: Period): string {
+  const d = new Date(dateStr);
+  if (period === 90) return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+  return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+
+export function InventoryFlow() {
+  const [period, setPeriod] = useState<Period>(30);
+
+  const { data, isLoading, isError } = useQuery<FlowPoint[]>({
+    queryKey: ['inventory-flow', period],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/analytics/flow?period=${period}`);
+      if (!response.ok) throw new Error('Failed to fetch inventory flow');
+      return response.json();
+    },
+  });
+
+  const totals = useMemo(() => {
+    if (!data) return { received: 0, sold: 0, net: 0 };
+    const received = data.reduce((s, d) => s + d.costReceived, 0);
+    const sold = data.reduce((s, d) => s + d.cogsSold, 0);
+    return { received, sold, net: received - sold };
+  }, [data]);
+
+  const chartData = useMemo(() => {
+    if (!data) return [];
+    return data.map(d => ({
+      ...d,
+      netFlow: d.costReceived - d.cogsSold,
+    }));
+  }, [data]);
+
+  return (
+    <Card>
+      <CardHeader>
+        <div className="flex items-center justify-between">
+          <div>
+            <CardTitle>Inventory Flow: Receiving vs Selling</CardTitle>
+            <p className="text-xs text-muted-foreground mt-1">
+              Daily cost of goods received vs cost of goods sold
+            </p>
+          </div>
+          <div className="flex gap-1">
+            {([30, 90] as Period[]).map((p) => (
+              <button
+                key={p}
+                onClick={() => setPeriod(p)}
+                className={`px-3 py-1 text-xs rounded-md transition-colors ${
+                  period === p
+                    ? 'bg-primary text-primary-foreground'
+                    : 'bg-muted text-muted-foreground hover:bg-muted/80'
+                }`}
+              >
+                {`${p}D`}
+              </button>
+            ))}
+          </div>
+        </div>
+      </CardHeader>
+      <CardContent>
+        {isError ? (
+          <div className="h-[400px] flex items-center justify-center">
+            <p className="text-sm text-destructive">Failed to load flow data</p>
+          </div>
+        ) : isLoading || !data ? (
+          <div className="h-[400px] flex items-center justify-center">
+            <div className="animate-pulse text-muted-foreground">Loading flow data...</div>
+          </div>
+        ) : (
+          <div className="space-y-4">
+            {/* Summary stats */}
+            <div className="grid gap-4 md:grid-cols-3">
+              <div className="flex items-center gap-3 rounded-lg border p-3">
+                <div className="rounded-full p-2 bg-green-500/10">
+                  <ArrowDownToLine className="h-4 w-4 text-green-500" />
+                </div>
+                <div>
+                  <p className="text-xs text-muted-foreground">Total Received</p>
+                  <p className="text-lg font-bold">{formatCurrency(totals.received)}</p>
+                </div>
+              </div>
+              <div className="flex items-center gap-3 rounded-lg border p-3">
+                <div className="rounded-full p-2 bg-blue-500/10">
+                  <ArrowUpFromLine className="h-4 w-4 text-blue-500" />
+                </div>
+                <div>
+                  <p className="text-xs text-muted-foreground">Total Sold (COGS)</p>
+                  <p className="text-lg font-bold">{formatCurrency(totals.sold)}</p>
+                </div>
+              </div>
+              <div className="flex items-center gap-3 rounded-lg border p-3">
+                <div className={`rounded-full p-2 ${totals.net >= 0 ? 'bg-amber-500/10' : 'bg-green-500/10'}`}>
+                  <TrendingUp className={`h-4 w-4 ${totals.net >= 0 ? 'text-amber-500' : 'text-green-500'}`} />
+                </div>
+                <div>
+                  <p className="text-xs text-muted-foreground">Net Change</p>
+                  <p className={`text-lg font-bold ${totals.net >= 0 ? 'text-amber-600' : 'text-green-600'}`}>
+                    {totals.net >= 0 ? '+' : ''}{formatCurrency(totals.net)}
+                  </p>
+                  <p className="text-xs text-muted-foreground">
+                    {totals.net >= 0 ? 'inventory growing' : 'inventory shrinking'}
+                  </p>
+                </div>
+              </div>
+            </div>
+
+            {/* Chart */}
+            <ResponsiveContainer width="100%" height={300}>
+              <ComposedChart data={chartData}>
+                <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+                <XAxis
+                  dataKey="date"
+                  tickFormatter={(v) => formatDate(v, period)}
+                  tick={{ fontSize: 12 }}
+                  interval={period === 90 ? 6 : 2}
+                />
+                <YAxis
+                  tickFormatter={formatCurrency}
+                  tick={{ fontSize: 12 }}
+                  width={60}
+                />
+                <Tooltip
+                  labelFormatter={(v) => new Date(v).toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric' })}
+                  formatter={(value: number, name: string) => [formatCurrency(value), name]}
+                />
+                <Legend />
+                <Bar
+                  dataKey="costReceived"
+                  fill={METRIC_COLORS.revenue}
+                  name="Received (Cost)"
+                  radius={[2, 2, 0, 0]}
+                  opacity={0.7}
+                />
+                <Bar
+                  dataKey="cogsSold"
+                  fill={METRIC_COLORS.orders}
+                  name="Sold (COGS)"
+                  radius={[2, 2, 0, 0]}
+                  opacity={0.7}
+                />
+                <Line
+                  type="monotone"
+                  dataKey="netFlow"
+                  stroke={METRIC_COLORS.comparison}
+                  name="Net Flow"
+                  strokeWidth={1.5}
+                  dot={false}
+                />
+              </ComposedChart>
+            </ResponsiveContainer>
+          </div>
+        )}
+      </CardContent>
+    </Card>
+  );
+}

inventory/src/components/analytics/InventoryTrends.tsx

@@ -0,0 +1,131 @@
+import { useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  ResponsiveContainer,
+  Bar,
+  XAxis,
+  YAxis,
+  Tooltip,
+  CartesianGrid,
+  Line,
+  ComposedChart,
+} from 'recharts';
+import config from '../../config';
+import { METRIC_COLORS } from '@/lib/dashboard/designTokens';
+
+interface TrendPoint {
+  date: string;
+  stockoutCount: number;
+  unitsSold: number;
+}
+
+type Period = 30 | 90 | 365;
+
+function formatDate(dateStr: string, period: Period): string {
+  const d = new Date(dateStr);
+  if (period === 365) return d.toLocaleDateString('en-US', { month: 'short', year: '2-digit' });
+  if (period === 90) return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+  return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+
+export function InventoryTrends() {
+  const [period, setPeriod] = useState<Period>(90);
+
+  const { data, isLoading, isError } = useQuery<TrendPoint[]>({
+    queryKey: ['inventory-trends', period],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/analytics/inventory-trends?period=${period}`);
+      if (!response.ok) throw new Error('Failed to fetch inventory trends');
+      return response.json();
+    },
+  });
+
+  return (
+    <Card>
+      <CardHeader>
+        <div className="flex items-center justify-between">
+          <div>
+            <CardTitle>Daily Sales Activity & Stockouts</CardTitle>
+            <p className="text-xs text-muted-foreground mt-1">
+              Units sold per day with stockout product count overlay
+            </p>
+          </div>
+          <div className="flex gap-1">
+            {([30, 90, 365] as Period[]).map((p) => (
+              <button
+                key={p}
+                onClick={() => setPeriod(p)}
+                className={`px-3 py-1 text-xs rounded-md transition-colors ${
+                  period === p
+                    ? 'bg-primary text-primary-foreground'
+                    : 'bg-muted text-muted-foreground hover:bg-muted/80'
+                }`}
+              >
+                {p === 365 ? '1Y' : `${p}D`}
+              </button>
+            ))}
+          </div>
+        </div>
+      </CardHeader>
+      <CardContent>
+        {isError ? (
+          <div className="h-[350px] flex items-center justify-center">
+            <p className="text-sm text-destructive">Failed to load trends data</p>
+          </div>
+        ) : isLoading || !data ? (
+          <div className="h-[350px] flex items-center justify-center">
+            <div className="animate-pulse text-muted-foreground">Loading trends...</div>
+          </div>
+        ) : (
+          <ResponsiveContainer width="100%" height={350}>
+            <ComposedChart data={data}>
+              <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+              <XAxis
+                dataKey="date"
+                tickFormatter={(v) => formatDate(v, period)}
+                tick={{ fontSize: 12 }}
+                interval={period === 365 ? 29 : period === 90 ? 6 : 2}
+              />
+              <YAxis
+                yAxisId="left"
+                tick={{ fontSize: 12 }}
+                width={60}
+                label={{ value: 'Units Sold', angle: -90, position: 'insideLeft', offset: -5, style: { fontSize: 11, fill: '#9ca3af' } }}
+              />
+              <YAxis
+                yAxisId="right"
+                orientation="right"
+                tick={{ fontSize: 12 }}
+                width={60}
+                label={{ value: 'Stockouts', angle: 90, position: 'insideRight', offset: -5, style: { fontSize: 11, fill: '#9ca3af' } }}
+              />
+              <Tooltip
+                labelFormatter={(v) => new Date(v).toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric' })}
+                formatter={(value: number, name: string) => [value.toLocaleString(), name]}
+              />
+              <Bar
+                yAxisId="left"
+                dataKey="unitsSold"
+                fill={METRIC_COLORS.orders}
+                name="Units Sold"
+                radius={[2, 2, 0, 0]}
+                opacity={0.7}
+              />
+              <Line
+                yAxisId="right"
+                type="monotone"
+                dataKey="stockoutCount"
+                stroke="#ef4444"
+                name="Products Stocked Out"
+                strokeWidth={1.5}
+                dot={false}
+                strokeDasharray="4 2"
+              />
+            </ComposedChart>
+          </ResponsiveContainer>
+        )}
+      </CardContent>
+    </Card>
+  );
+}

inventory/src/components/analytics/InventoryValueTrend.tsx

@@ -0,0 +1,159 @@
+import { useState } from 'react';
+import { useQuery } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  ResponsiveContainer,
+  Area,
+  XAxis,
+  YAxis,
+  Tooltip,
+  CartesianGrid,
+  Line,
+  ComposedChart,
+} from 'recharts';
+import config from '../../config';
+import { METRIC_COLORS } from '@/lib/dashboard/designTokens';
+import { formatCurrency } from '@/utils/formatCurrency';
+
+interface ValuePoint {
+  date: string;
+  totalValue: number;
+  productCount: number;
+}
+
+type Period = 30 | 90 | 365;
+
+function formatDate(dateStr: string, period: Period): string {
+  const d = new Date(dateStr);
+  if (period === 365) return d.toLocaleDateString('en-US', { month: 'short', year: '2-digit' });
+  if (period === 90) return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+  return d.toLocaleDateString('en-US', { month: 'short', day: 'numeric' });
+}
+
+export function InventoryValueTrend() {
+  const [period, setPeriod] = useState<Period>(90);
+
+  const { data, isLoading, isError } = useQuery<ValuePoint[]>({
+    queryKey: ['inventory-value', period],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/analytics/inventory-value?period=${period}`);
+      if (!response.ok) throw new Error('Failed to fetch inventory value');
+      return response.json();
+    },
+  });
+
+  const latest = data?.[data.length - 1];
+  const earliest = data?.[0];
+  const change = latest && earliest ? latest.totalValue - earliest.totalValue : 0;
+  const changePct = earliest && earliest.totalValue > 0
+    ? ((change / earliest.totalValue) * 100).toFixed(1)
+    : '0';
+
+  return (
+    <Card>
+      <CardHeader>
+        <div className="flex items-center justify-between">
+          <div>
+            <CardTitle>Inventory Value Over Time</CardTitle>
+            <p className="text-xs text-muted-foreground mt-1">
+              Total stock investment (cost) with product count overlay
+              {latest && (
+                <span className="ml-2">
+                  — Current: <span className="font-medium">{formatCurrency(latest.totalValue)}</span>
+                  {' '}
+                  <span className={change >= 0 ? 'text-green-600' : 'text-red-600'}>
+                    ({change >= 0 ? '+' : ''}{changePct}%)
+                  </span>
+                </span>
+              )}
+            </p>
+          </div>
+          <div className="flex gap-1">
+            {([30, 90, 365] as Period[]).map((p) => (
+              <button
+                key={p}
+                onClick={() => setPeriod(p)}
+                className={`px-3 py-1 text-xs rounded-md transition-colors ${
+                  period === p
+                    ? 'bg-primary text-primary-foreground'
+                    : 'bg-muted text-muted-foreground hover:bg-muted/80'
+                }`}
+              >
+                {p === 365 ? '1Y' : `${p}D`}
+              </button>
+            ))}
+          </div>
+        </div>
+      </CardHeader>
+      <CardContent>
+        {isError ? (
+          <div className="h-[350px] flex items-center justify-center">
+            <p className="text-sm text-destructive">Failed to load inventory value data</p>
+          </div>
+        ) : isLoading || !data ? (
+          <div className="h-[350px] flex items-center justify-center">
+            <div className="animate-pulse text-muted-foreground">Loading inventory value...</div>
+          </div>
+        ) : (
+          <ResponsiveContainer width="100%" height={350}>
+            <ComposedChart data={data}>
+              <defs>
+                <linearGradient id="valueGradient" x1="0" y1="0" x2="0" y2="1">
+                  <stop offset="5%" stopColor={METRIC_COLORS.revenue} stopOpacity={0.3} />
+                  <stop offset="95%" stopColor={METRIC_COLORS.revenue} stopOpacity={0.05} />
+                </linearGradient>
+              </defs>
+              <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+              <XAxis
+                dataKey="date"
+                tickFormatter={(v) => formatDate(v, period)}
+                tick={{ fontSize: 12 }}
+                interval={period === 365 ? 29 : period === 90 ? 6 : 2}
+              />
+              <YAxis
+                yAxisId="left"
+                tickFormatter={formatCurrency}
+                tick={{ fontSize: 12 }}
+                width={70}
+                label={{ value: 'Stock Value', angle: -90, position: 'insideLeft', offset: -5, style: { fontSize: 11, fill: '#9ca3af' } }}
+              />
+              <YAxis
+                yAxisId="right"
+                orientation="right"
+                tick={{ fontSize: 12 }}
+                width={60}
+                label={{ value: 'Products', angle: 90, position: 'insideRight', offset: -5, style: { fontSize: 11, fill: '#9ca3af' } }}
+              />
+              <Tooltip
+                labelFormatter={(v) => new Date(v).toLocaleDateString('en-US', { weekday: 'short', month: 'short', day: 'numeric', year: 'numeric' })}
+                formatter={(value: number, name: string) => [
+                  name === 'Stock Value' ? formatCurrency(value) : value.toLocaleString(),
+                  name,
+                ]}
+              />
+              <Area
+                yAxisId="left"
+                type="monotone"
+                dataKey="totalValue"
+                fill="url(#valueGradient)"
+                stroke={METRIC_COLORS.revenue}
+                strokeWidth={2}
+                name="Stock Value"
+              />
+              <Line
+                yAxisId="right"
+                type="monotone"
+                dataKey="productCount"
+                stroke={METRIC_COLORS.orders}
+                name="Products in Stock"
+                strokeWidth={1.5}
+                dot={false}
+                strokeDasharray="4 2"
+              />
+            </ComposedChart>
+          </ResponsiveContainer>
+        )}
+      </CardContent>
+    </Card>
+  );
+}

inventory/src/components/analytics/PortfolioAnalysis.tsx

@@ -0,0 +1,226 @@
+import { useQuery } from '@tanstack/react-query';
+import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
+import {
+  ResponsiveContainer,
+  BarChart,
+  Bar,
+  XAxis,
+  YAxis,
+  Tooltip,
+  Legend,
+  CartesianGrid,
+} from 'recharts';
+import config from '../../config';
+import { PackageX, Archive } from 'lucide-react';
+import { METRIC_COLORS } from '@/lib/dashboard/designTokens';
+import { formatCurrency } from '@/utils/formatCurrency';
+
+interface AbcItem {
+  abcClass: string;
+  productCount: number;
+  revenue: number;
+  stockCost: number;
+  profit: number;
+  unitsSold: number;
+}
+
+interface StockIssues {
+  deadStockCount: number;
+  deadStockCost: number;
+  deadStockRetail: number;
+  overstockCount: number;
+  overstockCost: number;
+  overstockRetail: number;
+}
+
+interface PortfolioData {
+  abcBreakdown: AbcItem[];
+  stockIssues: StockIssues;
+}
+
+export function PortfolioAnalysis() {
+  const { data, isLoading, isError } = useQuery<PortfolioData>({
+    queryKey: ['portfolio-analysis'],
+    queryFn: async () => {
+      const response = await fetch(`${config.apiUrl}/analytics/portfolio`);
+      if (!response.ok) throw new Error('Failed to fetch portfolio analysis');
+      return response.json();
+    },
+  });
+
+  if (isError) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>Portfolio & ABC Analysis</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[300px] flex items-center justify-center">
+            <p className="text-sm text-destructive">Failed to load portfolio data</p>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  if (isLoading || !data) {
+    return (
+      <Card>
+        <CardHeader><CardTitle>Portfolio & ABC Analysis</CardTitle></CardHeader>
+        <CardContent>
+          <div className="h-[300px] flex items-center justify-center">
+            <div className="animate-pulse text-muted-foreground">Loading portfolio...</div>
+          </div>
+        </CardContent>
+      </Card>
+    );
+  }
+
+  // Include all classes — rename N/A to "Unclassified"
+  const allClasses = data.abcBreakdown.map(r => ({
+    ...r,
+    abcClass: r.abcClass === 'N/A' ? 'Unclassified' : r.abcClass,
+  }));
+  const totalRevenue = allClasses.reduce((s, r) => s + r.revenue, 0);
+  const totalStockCost = allClasses.reduce((s, r) => s + r.stockCost, 0);
+  const totalProducts = allClasses.reduce((s, r) => s + r.productCount, 0);
+
+  // Compute percentage data for the grouped bar chart
+  const chartData = allClasses.map(r => ({
+    abcClass: r.abcClass === 'Unclassified' ? 'Unclassified' : `Class ${r.abcClass}`,
+    '% of Products': totalProducts > 0 ? Number(((r.productCount / totalProducts) * 100).toFixed(1)) : 0,
+    '% of Revenue': totalRevenue > 0 ? Number(((r.revenue / totalRevenue) * 100).toFixed(1)) : 0,
+    '% of Stock Investment': totalStockCost > 0 ? Number(((r.stockCost / totalStockCost) * 100).toFixed(1)) : 0,
+  }));
+
+  const abcOnly = allClasses.filter(r => ['A', 'B', 'C'].includes(r.abcClass));
+  const abcRevenue = abcOnly.reduce((s, r) => s + r.revenue, 0);
+  const aClass = allClasses.find(r => r.abcClass === 'A');
+
+  return (
+    <div className="space-y-4">
+      <div className="grid gap-4 md:grid-cols-2">
+        <Card>
+          <CardHeader>
+            <CardTitle>ABC Class Distribution</CardTitle>
+          </CardHeader>
+          <CardContent>
+            <ResponsiveContainer width="100%" height={300}>
+              <BarChart data={chartData}>
+                <CartesianGrid strokeDasharray="3 3" className="stroke-muted" />
+                <XAxis dataKey="abcClass" tick={{ fontSize: 12 }} />
+                <YAxis tickFormatter={(v) => `${v}%`} tick={{ fontSize: 12 }} />
+                <Tooltip formatter={(value: number) => [`${value}%`]} />
+                <Legend />
+                <Bar dataKey="% of Products" fill={METRIC_COLORS.orders} radius={[2, 2, 0, 0]} />
+                <Bar dataKey="% of Revenue" fill={METRIC_COLORS.revenue} radius={[2, 2, 0, 0]} />
+                <Bar dataKey="% of Stock Investment" fill={METRIC_COLORS.aov} radius={[2, 2, 0, 0]} />
+              </BarChart>
+            </ResponsiveContainer>
+          </CardContent>
+        </Card>
+
+        <div className="grid gap-4 grid-rows-3">
+          <Card>
+            <CardContent className="flex items-center gap-4 py-4">
+              <div className="rounded-full p-2 bg-green-500/10">
+                <TrendingUpIcon className="h-5 w-5 text-green-500" />
+              </div>
+              <div className="flex-1">
+                <p className="text-sm font-medium">A-Class Products</p>
+                <p className="text-xs text-muted-foreground">
+                  {aClass ? aClass.productCount.toLocaleString() : 0} products
+                </p>
+              </div>
+              <div className="text-right">
+                <p className="text-sm font-bold">
+                  {abcRevenue > 0 && aClass ? ((aClass.revenue / abcRevenue) * 100).toFixed(0) : 0}% of classified revenue
+                </p>
+                <p className="text-xs text-muted-foreground">
+                  {formatCurrency(aClass?.revenue || 0)} (30d)
+                </p>
+              </div>
+            </CardContent>
+          </Card>
+          <Card>
+            <CardContent className="flex items-center gap-4 py-4">
+              <div className="rounded-full p-2 bg-amber-500/10">
+                <Archive className="h-5 w-5 text-amber-500" />
+              </div>
+              <div className="flex-1">
+                <p className="text-sm font-medium">Dead Stock</p>
+                <p className="text-xs text-muted-foreground">
+                  {data.stockIssues.deadStockCount.toLocaleString()} products
+                </p>
+              </div>
+              <div className="text-right">
+                <p className="text-sm font-bold text-amber-500">
+                  {formatCurrency(data.stockIssues.deadStockCost)}
+                </p>
+                <p className="text-xs text-muted-foreground">capital tied up</p>
+              </div>
+            </CardContent>
+          </Card>
+          <Card>
+            <CardContent className="flex items-center gap-4 py-4">
+              <div className="rounded-full p-2 bg-red-500/10">
+                <PackageX className="h-5 w-5 text-red-500" />
+              </div>
+              <div className="flex-1">
+                <p className="text-sm font-medium">Overstock</p>
+                <p className="text-xs text-muted-foreground">
+                  {data.stockIssues.overstockCount.toLocaleString()} products
+                </p>
+              </div>
+              <div className="text-right">
+                <p className="text-sm font-bold text-red-500">
+                  {formatCurrency(data.stockIssues.overstockCost)}
+                </p>
+                <p className="text-xs text-muted-foreground">excess investment</p>
+              </div>
+            </CardContent>
+          </Card>
+        </div>
+      </div>
+
+      {/* ABC breakdown table */}
+      <Card>
+        <CardContent className="pt-6">
+          <div className="rounded-md border">
+            <table className="w-full text-sm">
+              <thead>
+                <tr className="border-b bg-muted/50">
+                  <th className="px-4 py-2 text-left font-medium">Class</th>
+                  <th className="px-4 py-2 text-right font-medium">Products</th>
+                  <th className="px-4 py-2 text-right font-medium">Revenue (30d)</th>
+                  <th className="px-4 py-2 text-right font-medium">Profit (30d)</th>
+                  <th className="px-4 py-2 text-right font-medium">Stock Cost</th>
+                  <th className="px-4 py-2 text-right font-medium">Units Sold (30d)</th>
+                </tr>
+              </thead>
+              <tbody>
+                {allClasses.map((row) => (
+                  <tr key={row.abcClass} className="border-b">
+                    <td className="px-4 py-2 font-medium">{row.abcClass === 'Unclassified' ? 'Unclassified' : `Class ${row.abcClass}`}</td>
+                    <td className="px-4 py-2 text-right">{row.productCount.toLocaleString()}</td>
+                    <td className="px-4 py-2 text-right">{formatCurrency(row.revenue)}</td>
+                    <td className="px-4 py-2 text-right">{formatCurrency(row.profit)}</td>
+                    <td className="px-4 py-2 text-right">{formatCurrency(row.stockCost)}</td>
+                    <td className="px-4 py-2 text-right">{row.unitsSold.toLocaleString()}</td>
+                  </tr>
+                ))}
+              </tbody>
+            </table>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+}
+
+function TrendingUpIcon({ className }: { className?: string }) {
+  return (
+    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2" strokeLinecap="round" strokeLinejoin="round" className={className}>
+      <polyline points="22 7 13.5 15.5 8.5 10.5 2 17" />
+      <polyline points="16 7 22 7 22 13" />
+    </svg>
+  );
+}

inventory/src/components/analytics/PriceAnalysis.tsx

@@ -1,182 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
-import { ResponsiveContainer, ScatterChart, Scatter, XAxis, YAxis, Tooltip, ZAxis, LineChart, Line } from 'recharts';
-import config from '../../config';
-
-interface PriceData {
-  pricePoints: {
-    price: number;
-    salesVolume: number;
-    revenue: number;
-    category: string;
-  }[];
-  elasticity: {
-    date: string;
-    price: number;
-    demand: number;
-  }[];
-  recommendations: {
-    product: string;
-    currentPrice: number;
-    recommendedPrice: number;
-    potentialRevenue: number;
-    confidence: number;
-  }[];
-}
-
-export function PriceAnalysis() {
-  const { data, isLoading } = useQuery<PriceData>({
-    queryKey: ['price-analysis'],
-    queryFn: async () => {
-      const response = await fetch(`${config.apiUrl}/analytics/pricing`);
-      if (!response.ok) {
-        throw new Error('Failed to fetch price analysis');
-      }
-      const rawData = await response.json();
-      return {
-        pricePoints: rawData.pricePoints.map((item: any) => ({
-          ...item,
-          price: Number(item.price) || 0,
-          salesVolume: Number(item.salesVolume) || 0,
-          revenue: Number(item.revenue) || 0
-        })),
-        elasticity: rawData.elasticity.map((item: any) => ({
-          ...item,
-          price: Number(item.price) || 0,
-          demand: Number(item.demand) || 0
-        })),
-        recommendations: rawData.recommendations.map((item: any) => ({
-          ...item,
-          currentPrice: Number(item.currentPrice) || 0,
-          recommendedPrice: Number(item.recommendedPrice) || 0,
-          potentialRevenue: Number(item.potentialRevenue) || 0,
-          confidence: Number(item.confidence) || 0
-        }))
-      };
-    },
-  });
-
-  if (isLoading || !data) {
-    return <div>Loading price analysis...</div>;
-  }
-
-  return (
-    <div className="grid gap-4">
-      <div className="grid gap-4 md:grid-cols-2">
-        <Card>
-          <CardHeader>
-            <CardTitle>Price Point Analysis</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <ResponsiveContainer width="100%" height={300}>
-              <ScatterChart>
-                <XAxis 
-                  dataKey="price" 
-                  name="Price"
-                  tickFormatter={(value) => `$${value}`}
-                />
-                <YAxis 
-                  dataKey="salesVolume" 
-                  name="Sales Volume"
-                />
-                <ZAxis 
-                  dataKey="revenue" 
-                  range={[50, 400]} 
-                  name="Revenue"
-                />
-                <Tooltip 
-                  formatter={(value: number, name: string) => {
-                    if (name === 'Price') return [`$${value}`, name];
-                    if (name === 'Sales Volume') return [value.toLocaleString(), name];
-                    if (name === 'Revenue') return [`$${value.toLocaleString()}`, name];
-                    return [value, name];
-                  }}
-                />
-                <Scatter 
-                  data={data.pricePoints} 
-                  fill="#a78bfa"
-                  name="Products"
-                />
-              </ScatterChart>
-            </ResponsiveContainer>
-          </CardContent>
-        </Card>
-
-        <Card>
-          <CardHeader>
-            <CardTitle>Price Elasticity</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <ResponsiveContainer width="100%" height={300}>
-              <LineChart data={data.elasticity}>
-                <XAxis 
-                  dataKey="date" 
-                  tickFormatter={(value) => new Date(value).toLocaleDateString()}
-                />
-                <YAxis yAxisId="left" orientation="left" stroke="#a78bfa" />
-                <YAxis 
-                  yAxisId="right" 
-                  orientation="right" 
-                  stroke="#4ade80"
-                  tickFormatter={(value) => `$${value}`}
-                />
-                <Tooltip
-                  labelFormatter={(label) => new Date(label).toLocaleDateString()}
-                  formatter={(value: number, name: string) => {
-                    if (name === 'Price') return [`$${value}`, name];
-                    return [value.toLocaleString(), name];
-                  }}
-                />
-                <Line 
-                  yAxisId="left"
-                  type="monotone" 
-                  dataKey="demand" 
-                  stroke="#a78bfa" 
-                  name="Demand"
-                />
-                <Line 
-                  yAxisId="right"
-                  type="monotone" 
-                  dataKey="price" 
-                  stroke="#4ade80" 
-                  name="Price"
-                />
-              </LineChart>
-            </ResponsiveContainer>
-          </CardContent>
-        </Card>
-      </div>
-
-      <Card>
-        <CardHeader>
-          <CardTitle>Price Optimization Recommendations</CardTitle>
-        </CardHeader>
-        <CardContent>
-          <div className="space-y-4">
-            {data.recommendations.map((item) => (
-              <div key={`${item.product}-${item.currentPrice}`} className="flex items-center">
-                <div className="flex-1">
-                  <p className="text-sm font-medium">{item.product}</p>
-                  <p className="text-sm text-muted-foreground">
-                    Current Price: ${item.currentPrice.toFixed(2)}
-                  </p>
-                </div>
-                <div className="ml-4 text-right space-y-1">
-                  <p className="text-sm font-medium">
-                    Recommended: ${item.recommendedPrice.toFixed(2)}
-                  </p>
-                  <p className="text-sm text-muted-foreground">
-                    Potential Revenue: ${item.potentialRevenue.toLocaleString()}
-                  </p>
-                  <p className="text-sm text-muted-foreground">
-                    Confidence: {item.confidence}%
-                  </p>
-                </div>
-              </div>
-            ))}
-          </div>
-        </CardContent>
-      </Card>
-    </div>
-  );
-} 

inventory/src/components/analytics/ProfitAnalysis.tsx

@@ -1,179 +0,0 @@
-import { useQuery } from '@tanstack/react-query';
-import { Card, CardContent, CardHeader, CardTitle } from '@/components/ui/card';
-import { ResponsiveContainer, BarChart, Bar, XAxis, YAxis, Tooltip, LineChart, Line } from 'recharts';
-import config from '../../config';
-
-interface ProfitData {
-  byCategory: {
-    category: string;
-    categoryPath: string;  // Full hierarchy path
-    profitMargin: number;
-    revenue: number;
-    cost: number;
-  }[];
-  overTime: {
-    date: string;
-    profitMargin: number;
-    revenue: number;
-    cost: number;
-  }[];
-  topProducts: {
-    product: string;
-    category: string;
-    categoryPath: string;  // Full hierarchy path
-    profitMargin: number;
-    revenue: number;
-    cost: number;
-  }[];
-}
-
-export function ProfitAnalysis() {
-  const { data, isLoading } = useQuery<ProfitData>({
-    queryKey: ['profit-analysis'],
-    queryFn: async () => {
-      const response = await fetch(`${config.apiUrl}/analytics/profit`);
-      if (!response.ok) {
-        throw new Error('Failed to fetch profit analysis');
-      }
-      const rawData = await response.json();
-      return {
-        byCategory: rawData.byCategory.map((item: any) => ({
-          ...item,
-          categoryPath: item.categoryPath || item.category,
-          profitMargin: Number(item.profitMargin) || 0,
-          revenue: Number(item.revenue) || 0,
-          cost: Number(item.cost) || 0
-        })),
-        overTime: rawData.overTime.map((item: any) => ({
-          ...item,
-          profitMargin: Number(item.profitMargin) || 0,
-          revenue: Number(item.revenue) || 0,
-          cost: Number(item.cost) || 0
-        })),
-        topProducts: rawData.topProducts.map((item: any) => ({
-          ...item,
-          categoryPath: item.categoryPath || item.category,
-          profitMargin: Number(item.profitMargin) || 0,
-          revenue: Number(item.revenue) || 0,
-          cost: Number(item.cost) || 0
-        }))
-      };
-    },
-  });
-
-  if (isLoading || !data) {
-    return <div>Loading profit analysis...</div>;
-  }
-
-  const getShortCategoryName = (path: string) => path.split(' > ').pop() || path;
-
-  return (
-    <div className="grid gap-4">
-      <div className="grid gap-4 md:grid-cols-2">
-        <Card>
-          <CardHeader>
-            <CardTitle>Profit Margins by Category</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <ResponsiveContainer width="100%" height={300}>
-              <BarChart data={data.byCategory}>
-                <XAxis 
-                  dataKey="categoryPath" 
-                  tick={({ x, y, payload }) => (
-                    <g transform={`translate(${x},${y})`}>
-                      <text
-                        x={0}
-                        y={0}
-                        dy={16}
-                        textAnchor="end"
-                        fill="#888888"
-                        transform="rotate(-35)"
-                      >
-                        {getShortCategoryName(payload.value)}
-                      </text>
-                    </g>
-                  )}
-                />
-                <YAxis tickFormatter={(value) => `${value}%`} />
-                <Tooltip 
-                  formatter={(value: number, _: string, props: any) => [
-                    `${value.toFixed(1)}%`,
-                    <div key="tooltip">
-                      <div className="font-medium">Category Path:</div>
-                      <div className="text-sm text-muted-foreground">{props.payload.categoryPath}</div>
-                      <div className="mt-1">Profit Margin</div>
-                    </div>
-                  ]}
-                />
-                <Bar 
-                  dataKey="profitMargin" 
-                  fill="#4ade80"
-                  name="Profit Margin"
-                />
-              </BarChart>
-            </ResponsiveContainer>
-          </CardContent>
-        </Card>
-        
-        <Card>
-          <CardHeader>
-            <CardTitle>Profit Margin Trend</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <ResponsiveContainer width="100%" height={300}>
-              <LineChart data={data.overTime}>
-                <XAxis 
-                  dataKey="date" 
-                  tickFormatter={(value) => new Date(value).toLocaleDateString()}
-                />
-                <YAxis tickFormatter={(value) => `${value}%`} />
-                <Tooltip
-                  labelFormatter={(label) => new Date(label).toLocaleDateString()}
-                  formatter={(value: number) => [`${value.toFixed(1)}%`, 'Profit Margin']}
-                />
-                <Line 
-                  type="monotone" 
-                  dataKey="profitMargin" 
-                  stroke="#4ade80" 
-                  name="Profit Margin"
-                />
-              </LineChart>
-            </ResponsiveContainer>
-          </CardContent>
-        </Card>
-      </div>
-
-      <Card>
-        <CardHeader>
-          <CardTitle>Top Performing Products by Profit Margin</CardTitle>
-        </CardHeader>
-        <CardContent>
-          <div className="space-y-4">
-            {data.topProducts.map((product) => (
-              <div key={`${product.product}-${product.category}`} className="flex items-center">
-                <div className="flex-1">
-                  <p className="text-sm font-medium">{product.product}</p>
-                  <div className="text-xs text-muted-foreground space-y-1">
-                    <p className="font-medium">Category:</p>
-                    <p>{product.categoryPath}</p>
-                  </div>
-                  <p className="text-sm text-muted-foreground mt-1">
-                    Revenue: ${product.revenue.toLocaleString()}
-                  </p>
-                </div>
-                <div className="ml-4 text-right">
-                  <p className="text-sm font-medium">
-                    {product.profitMargin.toFixed(1)}% margin
-                  </p>
-                  <p className="text-sm text-muted-foreground">
-                    Cost: ${product.cost.toLocaleString()}
-                  </p>
-                </div>
-              </div>
-            ))}
-          </div>
-        </CardContent>
-      </Card>
-    </div>
-  );
-}