ci: Bump version to 0.7.24 [skip ci]

notes-to-ai4.txt

@@ -13,6 +13,12 @@ RULES:
 
 
 
+latest refacter
+
+Refactor `RecipeSuggester.test.tsx` to use `renderWithProviders`.
+Create a new test file for `StatCard.tsx` to verify its props and rendering.
+
+
 
 
 UPC SCANNING !

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "flyer-crawler",
-  "version": "0.7.6",
+  "version": "0.7.24",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flyer-crawler",
-      "version": "0.7.6",
+      "version": "0.7.24",
       "dependencies": {
         "@bull-board/api": "^6.14.2",
         "@bull-board/express": "^6.14.2",

package.json

@@ -1,7 +1,7 @@
 {
   "name": "flyer-crawler",
   "private": true,
-  "version": "0.7.6",
+  "version": "0.7.24",
   "type": "module",
   "scripts": {
     "dev": "concurrently \"npm:start:dev\" \"vite\"",

sql/master_schema_rollup.sql

@@ -1248,7 +1248,8 @@ INSERT INTO public.achievements (name, description, icon, points_value) VALUES
 ('List Sharer', 'Share a shopping list with another user for the first time.', 'list', 20),
 ('First Favorite', 'Mark a recipe as one of your favorites.', 'heart', 5),
 ('First Fork', 'Make a personal copy of a public recipe.', 'git-fork', 10),
-('First Budget Created', 'Create your first budget to track spending.', 'piggy-bank', 15)
+('First Budget Created', 'Create your first budget to track spending.', 'piggy-bank', 15),
+('First-Upload', 'Upload your first flyer.', 'upload-cloud', 25)
 ON CONFLICT (name) DO NOTHING;
 
 -- ============================================================================
@@ -2557,16 +2558,21 @@ DROP FUNCTION IF EXISTS public.log_new_flyer();
 CREATE OR REPLACE FUNCTION public.log_new_flyer()
 RETURNS TRIGGER AS $$
 BEGIN
-    INSERT INTO public.activity_log (action, display_text, icon, details)
+    -- If the flyer was uploaded by a registered user, award the 'First-Upload' achievement.
+    -- The award_achievement function handles checking if the user already has it.
+    IF NEW.uploaded_by IS NOT NULL THEN
+        PERFORM public.award_achievement(NEW.uploaded_by, 'First-Upload');
+    END IF;
+
+    INSERT INTO public.activity_log (user_id, action, display_text, icon, details)
     VALUES (
+        NEW.uploaded_by, -- Log the user who uploaded it
         'flyer_uploaded',
         'A new flyer for ' || (SELECT name FROM public.stores WHERE store_id = NEW.store_id) || ' has been uploaded.',
         'file-text',
         jsonb_build_object(
             'flyer_id', NEW.flyer_id,
-            'store_name', (SELECT name FROM public.stores WHERE store_id = NEW.store_id),
-            'valid_from', to_char(NEW.valid_from, 'YYYY-MM-DD'),
-            'valid_to', to_char(NEW.valid_to, 'YYYY-MM-DD')
+            'store_name', (SELECT name FROM public.stores WHERE store_id = NEW.store_id)
         )
     );
     RETURN NEW;

src/components/AchievementsList.test.tsx

@@ -1,9 +1,10 @@
 // src/components/AchievementsList.test.tsx
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { screen } from '@testing-library/react';
 import { describe, it, expect } from 'vitest';
 import { AchievementsList } from './AchievementsList';
 import { createMockUserAchievement } from '../tests/utils/mockFactories';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 describe('AchievementsList', () => {
   it('should render the list of achievements with correct details', () => {
@@ -24,7 +25,7 @@ describe('AchievementsList', () => {
       createMockUserAchievement({ achievement_id: 3, name: 'Unknown Achievement', icon: 'star' }), // This icon is not in the component's map
     ];
 
-    render(<AchievementsList achievements={mockAchievements} />);
+    renderWithProviders(<AchievementsList achievements={mockAchievements} />);
 
     expect(screen.getByRole('heading', { name: /achievements/i })).toBeInTheDocument();
 
@@ -44,7 +45,7 @@ describe('AchievementsList', () => {
   });
 
   it('should render a message when there are no achievements', () => {
-    render(<AchievementsList achievements={[]} />);
+    renderWithProviders(<AchievementsList achievements={[]} />);
     expect(
       screen.getByText('No achievements earned yet. Keep exploring to unlock them!'),
     ).toBeInTheDocument();

src/components/AdminRoute.test.tsx

@@ -1,11 +1,12 @@
 // src/components/AdminRoute.test.tsx
 import React from 'react';
-import { render, screen } from '@testing-library/react';
-import { describe, it, expect } from 'vitest';
-import { MemoryRouter, Routes, Route } from 'react-router-dom';
+import { screen } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+import { Routes, Route } from 'react-router-dom';
 import { AdminRoute } from './AdminRoute';
 import type { Profile } from '../types';
 import { createMockProfile } from '../tests/utils/mockFactories';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Unmock the component to test the real implementation
 vi.unmock('./AdminRoute');
@@ -14,15 +15,14 @@ const AdminContent = () => <div>Admin Page Content</div>;
 const HomePage = () => <div>Home Page</div>;
 
 const renderWithRouter = (profile: Profile | null, initialPath: string) => {
-  render(
-    <MemoryRouter initialEntries={[initialPath]}>
-      <Routes>
-        <Route path="/" element={<HomePage />} />
-        <Route path="/admin" element={<AdminRoute profile={profile} />}>
-          <Route index element={<AdminContent />} />
-        </Route>
-      </Routes>
-    </MemoryRouter>,
+  renderWithProviders(
+    <Routes>
+      <Route path="/" element={<HomePage />} />
+      <Route path="/admin" element={<AdminRoute profile={profile} />}>
+        <Route index element={<AdminContent />} />
+      </Route>
+    </Routes>,
+    { initialEntries: [initialPath] },
   );
 };
 

src/components/AnonymousUserBanner.test.tsx

@@ -1,8 +1,9 @@
 // src/components/AnonymousUserBanner.test.tsx
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { screen, fireEvent } from '@testing-library/react';
 import { describe, it, expect, vi } from 'vitest';
 import { AnonymousUserBanner } from './AnonymousUserBanner';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Mock the icon to ensure it is rendered correctly
 vi.mock('./icons/InformationCircleIcon', () => ({
@@ -14,7 +15,7 @@ vi.mock('./icons/InformationCircleIcon', () => ({
 describe('AnonymousUserBanner', () => {
   it('should render the banner with the correct text content and accessibility role', () => {
     const mockOnOpenProfile = vi.fn();
-    render(<AnonymousUserBanner onOpenProfile={mockOnOpenProfile} />);
+    renderWithProviders(<AnonymousUserBanner onOpenProfile={mockOnOpenProfile} />);
 
     // Check for accessibility role
     expect(screen.getByRole('alert')).toBeInTheDocument();
@@ -30,7 +31,7 @@ describe('AnonymousUserBanner', () => {
 
   it('should call onOpenProfile when the "sign up or log in" button is clicked', () => {
     const mockOnOpenProfile = vi.fn();
-    render(<AnonymousUserBanner onOpenProfile={mockOnOpenProfile} />);
+    renderWithProviders(<AnonymousUserBanner onOpenProfile={mockOnOpenProfile} />);
 
     const loginButton = screen.getByRole('button', { name: /sign up or log in/i });
     fireEvent.click(loginButton);

src/components/AppGuard.test.tsx

@@ -1,14 +1,16 @@
 // src/components/AppGuard.test.tsx
 import React from 'react';
-import { render, screen, waitFor } from '@testing-library/react';
+import { screen, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { AppGuard } from './AppGuard';
 import { useAppInitialization } from '../hooks/useAppInitialization';
 import { useModal } from '../hooks/useModal';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Mock dependencies
 vi.mock('../hooks/useAppInitialization');
 vi.mock('../hooks/useModal');
+vi.mock('../services/apiClient');
 vi.mock('./WhatsNewModal', () => ({
   WhatsNewModal: ({ isOpen }: { isOpen: boolean }) =>
     isOpen ? <div data-testid="whats-new-modal-mock" /> : null,
@@ -38,7 +40,7 @@ describe('AppGuard', () => {
   });
 
   it('should render children', () => {
-    render(
+    renderWithProviders(
       <AppGuard>
         <div>Child Content</div>
       </AppGuard>,
@@ -51,7 +53,7 @@ describe('AppGuard', () => {
       ...mockedUseModal(),
       isModalOpen: (modalId) => modalId === 'whatsNew',
     });
-    render(
+    renderWithProviders(
       <AppGuard>
         <div>Child</div>
       </AppGuard>,
@@ -64,7 +66,7 @@ describe('AppGuard', () => {
       isDarkMode: true,
       unitSystem: 'imperial',
     });
-    render(
+    renderWithProviders(
       <AppGuard>
         <div>Child</div>
       </AppGuard>,
@@ -78,7 +80,7 @@ describe('AppGuard', () => {
   });
 
   it('should set light mode styles for toaster', async () => {
-    render(
+    renderWithProviders(
       <AppGuard>
         <div>Child</div>
       </AppGuard>,

src/components/ConfirmationModal.test.tsx

@@ -1,8 +1,9 @@
 // src/components/ConfirmationModal.test.tsx
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { screen, fireEvent } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { ConfirmationModal } from './ConfirmationModal';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 describe('ConfirmationModal (in components)', () => {
   const mockOnClose = vi.fn();
@@ -21,12 +22,12 @@ describe('ConfirmationModal (in components)', () => {
   });
 
   it('should not render when isOpen is false', () => {
-    const { container } = render(<ConfirmationModal {...defaultProps} isOpen={false} />);
+    const { container } = renderWithProviders(<ConfirmationModal {...defaultProps} isOpen={false} />);
     expect(container.firstChild).toBeNull();
   });
 
   it('should render correctly when isOpen is true', () => {
-    render(<ConfirmationModal {...defaultProps} />);
+    renderWithProviders(<ConfirmationModal {...defaultProps} />);
     expect(screen.getByRole('heading', { name: 'Confirm Action' })).toBeInTheDocument();
     expect(screen.getByText('Are you sure you want to do this?')).toBeInTheDocument();
     expect(screen.getByRole('button', { name: 'Confirm' })).toBeInTheDocument();
@@ -34,38 +35,38 @@ describe('ConfirmationModal (in components)', () => {
   });
 
   it('should call onConfirm when the confirm button is clicked', () => {
-    render(<ConfirmationModal {...defaultProps} />);
+    renderWithProviders(<ConfirmationModal {...defaultProps} />);
     fireEvent.click(screen.getByRole('button', { name: 'Confirm' }));
     expect(mockOnConfirm).toHaveBeenCalledTimes(1);
   });
 
   it('should call onClose when the cancel button is clicked', () => {
-    render(<ConfirmationModal {...defaultProps} />);
+    renderWithProviders(<ConfirmationModal {...defaultProps} />);
     fireEvent.click(screen.getByRole('button', { name: 'Cancel' }));
     expect(mockOnClose).toHaveBeenCalledTimes(1);
   });
 
   it('should call onClose when the close icon is clicked', () => {
-    render(<ConfirmationModal {...defaultProps} />);
+    renderWithProviders(<ConfirmationModal {...defaultProps} />);
     fireEvent.click(screen.getByLabelText('Close confirmation modal'));
     expect(mockOnClose).toHaveBeenCalledTimes(1);
   });
 
   it('should call onClose when the overlay is clicked', () => {
-    render(<ConfirmationModal {...defaultProps} />);
+    renderWithProviders(<ConfirmationModal {...defaultProps} />);
     // The overlay is the parent of the modal content div
     fireEvent.click(screen.getByRole('dialog'));
     expect(mockOnClose).toHaveBeenCalledTimes(1);
   });
 
   it('should not call onClose when clicking inside the modal content', () => {
-    render(<ConfirmationModal {...defaultProps} />);
+    renderWithProviders(<ConfirmationModal {...defaultProps} />);
     fireEvent.click(screen.getByText('Are you sure you want to do this?'));
     expect(mockOnClose).not.toHaveBeenCalled();
   });
 
   it('should render custom button text and classes', () => {
-    render(
+    renderWithProviders(
       <ConfirmationModal
         {...defaultProps}
         confirmButtonText="Yes, Delete"

src/components/DarkModeToggle.test.tsx

@@ -1,8 +1,9 @@
 // src/components/DarkModeToggle.test.tsx
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { screen, fireEvent } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { DarkModeToggle } from './DarkModeToggle';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Mock the icon components to isolate the toggle's logic
 vi.mock('./icons/SunIcon', () => ({
@@ -20,7 +21,7 @@ describe('DarkModeToggle', () => {
   });
 
   it('should render in light mode state', () => {
-    render(<DarkModeToggle isDarkMode={false} onToggle={mockOnToggle} />);
+    renderWithProviders(<DarkModeToggle isDarkMode={false} onToggle={mockOnToggle} />);
 
     const checkbox = screen.getByRole('checkbox');
     expect(checkbox).not.toBeChecked();
@@ -29,7 +30,7 @@ describe('DarkModeToggle', () => {
   });
 
   it('should render in dark mode state', () => {
-    render(<DarkModeToggle isDarkMode={true} onToggle={mockOnToggle} />);
+    renderWithProviders(<DarkModeToggle isDarkMode={true} onToggle={mockOnToggle} />);
 
     const checkbox = screen.getByRole('checkbox');
     expect(checkbox).toBeChecked();
@@ -38,7 +39,7 @@ describe('DarkModeToggle', () => {
   });
 
   it('should call onToggle when the label is clicked', () => {
-    render(<DarkModeToggle isDarkMode={false} onToggle={mockOnToggle} />);
+    renderWithProviders(<DarkModeToggle isDarkMode={false} onToggle={mockOnToggle} />);
 
     // Clicking the label triggers the checkbox change
     const label = screen.getByTitle('Switch to Dark Mode');

src/components/Dashboard.test.tsx

@@ -0,0 +1,67 @@
+// src/components/Dashboard.test.tsx
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { screen } from '@testing-library/react';
+import { Dashboard } from './Dashboard';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
+
+// Mock child components to isolate Dashboard logic
+// Note: The Dashboard component imports these using '../components/RecipeSuggester'
+// which resolves to the same file as './RecipeSuggester' when inside src/components.
+vi.mock('./RecipeSuggester', () => ({
+  RecipeSuggester: () => <div data-testid="recipe-suggester-mock">Recipe Suggester</div>,
+}));
+
+vi.mock('./FlyerCountDisplay', () => ({
+  FlyerCountDisplay: () => <div data-testid="flyer-count-display-mock">Flyer Count Display</div>,
+}));
+
+vi.mock('./Leaderboard', () => ({
+  Leaderboard: () => <div data-testid="leaderboard-mock">Leaderboard</div>,
+}));
+
+describe('Dashboard Component', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('renders the dashboard title', () => {
+    console.log('TEST: Verifying dashboard title render');
+    renderWithProviders(<Dashboard />);
+    expect(screen.getByRole('heading', { name: /dashboard/i, level: 1 })).toBeInTheDocument();
+  });
+
+  it('renders the RecipeSuggester widget', () => {
+    console.log('TEST: Verifying RecipeSuggester presence');
+    renderWithProviders(<Dashboard />);
+    expect(screen.getByTestId('recipe-suggester-mock')).toBeInTheDocument();
+  });
+
+  it('renders the FlyerCountDisplay widget within the "Your Flyers" section', () => {
+    console.log('TEST: Verifying FlyerCountDisplay presence and section title');
+    renderWithProviders(<Dashboard />);
+
+    // Check for the section heading
+    expect(screen.getByRole('heading', { name: /your flyers/i, level: 2 })).toBeInTheDocument();
+
+    // Check for the component
+    expect(screen.getByTestId('flyer-count-display-mock')).toBeInTheDocument();
+  });
+
+  it('renders the Leaderboard widget in the sidebar area', () => {
+    console.log('TEST: Verifying Leaderboard presence');
+    renderWithProviders(<Dashboard />);
+    expect(screen.getByTestId('leaderboard-mock')).toBeInTheDocument();
+  });
+
+  it('renders with the correct grid layout classes', () => {
+    console.log('TEST: Verifying layout classes');
+    const { container } = renderWithProviders(<Dashboard />);
+
+    // The main grid container
+    const gridContainer = container.querySelector('.grid');
+    expect(gridContainer).toBeInTheDocument();
+    expect(gridContainer).toHaveClass('grid-cols-1');
+    expect(gridContainer).toHaveClass('lg:grid-cols-3');
+    expect(gridContainer).toHaveClass('gap-6');
+  });
+});

src/components/Dashboard.tsx

@@ -0,0 +1,33 @@
+import React from 'react';
+import { RecipeSuggester } from '../components/RecipeSuggester';
+import { FlyerCountDisplay } from '../components/FlyerCountDisplay';
+import { Leaderboard } from '../components/Leaderboard';
+
+export const Dashboard: React.FC = () => {
+  return (
+    <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 py-8">
+      <h1 className="text-2xl font-bold text-gray-900 dark:text-white mb-6">Dashboard</h1>
+      
+      <div className="grid grid-cols-1 lg:grid-cols-3 gap-6">
+        {/* Main Content Area */}
+        <div className="lg:col-span-2 space-y-6">
+          {/* Recipe Suggester Section */}
+          <RecipeSuggester />
+
+          {/* Other Dashboard Widgets */}
+          <div className="bg-white dark:bg-gray-800 shadow rounded-lg p-6">
+            <h2 className="text-lg font-medium text-gray-900 dark:text-white mb-4">Your Flyers</h2>
+            <FlyerCountDisplay />
+          </div>
+        </div>
+
+        {/* Sidebar Area */}
+        <div className="space-y-6">
+          <Leaderboard />
+        </div>
+      </div>
+    </div>
+  );
+};
+
+export default Dashboard;

src/components/ErrorDisplay.test.tsx

@@ -1,24 +1,25 @@
 // src/components/ErrorDisplay.test.tsx
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { screen } from '@testing-library/react';
 import { describe, it, expect } from 'vitest';
 import { ErrorDisplay } from './ErrorDisplay';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 describe('ErrorDisplay (in components)', () => {
   it('should not render when the message is empty', () => {
-    const { container } = render(<ErrorDisplay message="" />);
+    const { container } = renderWithProviders(<ErrorDisplay message="" />);
     expect(container.firstChild).toBeNull();
   });
 
   it('should not render when the message is null', () => {
     // The component expects a string, but we test for nullish values as a safeguard.
-    const { container } = render(<ErrorDisplay message={null as unknown as string} />);
+    const { container } = renderWithProviders(<ErrorDisplay message={null as unknown as string} />);
     expect(container.firstChild).toBeNull();
   });
 
   it('should render the error message when provided', () => {
     const errorMessage = 'Something went terribly wrong.';
-    render(<ErrorDisplay message={errorMessage} />);
+    renderWithProviders(<ErrorDisplay message={errorMessage} />);
 
     const alert = screen.getByRole('alert');
     expect(alert).toBeInTheDocument();

src/components/FlyerCorrectionTool.test.tsx

@@ -1,10 +1,11 @@
 // src/components/FlyerCorrectionTool.test.tsx
 import React from 'react';
-import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
+import { screen, fireEvent, waitFor, act } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, type Mocked } from 'vitest';
 import { FlyerCorrectionTool } from './FlyerCorrectionTool';
 import * as aiApiClient from '../services/aiApiClient';
 import { notifyError, notifySuccess } from '../services/notificationService';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Unmock the component to test the real implementation
 vi.unmock('./FlyerCorrectionTool');
@@ -54,12 +55,12 @@ describe('FlyerCorrectionTool', () => {
   });
 
   it('should not render when isOpen is false', () => {
-    const { container } = render(<FlyerCorrectionTool {...defaultProps} isOpen={false} />);
+    const { container } = renderWithProviders(<FlyerCorrectionTool {...defaultProps} isOpen={false} />);
     expect(container.firstChild).toBeNull();
   });
 
   it('should render correctly when isOpen is true', () => {
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
     expect(screen.getByRole('heading', { name: /flyer correction tool/i })).toBeInTheDocument();
     expect(screen.getByAltText('Flyer for correction')).toBeInTheDocument();
     expect(screen.getByRole('button', { name: /extract store name/i })).toBeInTheDocument();
@@ -67,7 +68,7 @@ describe('FlyerCorrectionTool', () => {
   });
 
   it('should call onClose when the close button is clicked', () => {
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
     // Use the specific aria-label defined in the component to find the close button
     const closeButton = screen.getByLabelText(/close correction tool/i);
     fireEvent.click(closeButton);
@@ -75,13 +76,13 @@ describe('FlyerCorrectionTool', () => {
   });
 
   it('should have disabled extraction buttons initially', () => {
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
     expect(screen.getByRole('button', { name: /extract store name/i })).toBeDisabled();
     expect(screen.getByRole('button', { name: /extract sale dates/i })).toBeDisabled();
   });
 
   it('should enable extraction buttons after a selection is made', () => {
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
     const canvas = screen.getByRole('dialog').querySelector('canvas')!;
 
     // Simulate drawing a rectangle
@@ -94,7 +95,7 @@ describe('FlyerCorrectionTool', () => {
   });
 
   it('should stop drawing when the mouse leaves the canvas', () => {
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
     const canvas = screen.getByRole('dialog').querySelector('canvas')!;
 
     fireEvent.mouseDown(canvas, { clientX: 10, clientY: 10 });
@@ -114,7 +115,7 @@ describe('FlyerCorrectionTool', () => {
     });
     mockedAiApiClient.rescanImageArea.mockReturnValue(rescanPromise);
 
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
 
     // Wait for the image fetch to complete to ensure 'imageFile' state is populated
     console.log('--- [TEST LOG] ---: Awaiting image fetch inside component...');
@@ -192,7 +193,7 @@ describe('FlyerCorrectionTool', () => {
     // Mock fetch to reject
     global.fetch = vi.fn(() => Promise.reject(new Error('Network error'))) as Mocked<typeof fetch>;
 
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
 
     await waitFor(() => {
       expect(mockedNotifyError).toHaveBeenCalledWith('Could not load the image for correction.');
@@ -211,7 +212,7 @@ describe('FlyerCorrectionTool', () => {
       return new Promise(() => {});
     }) as Mocked<typeof fetch>;
 
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
 
     const canvas = screen.getByRole('dialog').querySelector('canvas')!;
 
@@ -238,7 +239,7 @@ describe('FlyerCorrectionTool', () => {
   it('should handle non-standard API errors during rescan', async () => {
     console.log('TEST: Starting "should handle non-standard API errors during rescan"');
     mockedAiApiClient.rescanImageArea.mockRejectedValue('A plain string error');
-    render(<FlyerCorrectionTool {...defaultProps} />);
+    renderWithProviders(<FlyerCorrectionTool {...defaultProps} />);
 
     // Wait for image fetch to ensure imageFile is set before we interact
     await waitFor(() => expect(global.fetch).toHaveBeenCalled());

src/components/FlyerCountDisplay.test.tsx

@@ -1,11 +1,12 @@
 // src/components/FlyerCountDisplay.test.tsx
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { screen } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { FlyerCountDisplay } from './FlyerCountDisplay';
 import { useFlyers } from '../hooks/useFlyers';
 import type { Flyer } from '../types';
 import { createMockFlyer } from '../tests/utils/mockFactories';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Mock the dependencies
 vi.mock('../hooks/useFlyers');
@@ -32,7 +33,7 @@ describe('FlyerCountDisplay', () => {
     });
 
     // Act: Render the component.
-    render(<FlyerCountDisplay />);
+    renderWithProviders(<FlyerCountDisplay />);
 
     // Assert: Check that the loading spinner is visible.
     expect(screen.getByTestId('loading-spinner')).toBeInTheDocument();
@@ -53,7 +54,7 @@ describe('FlyerCountDisplay', () => {
     });
 
     // Act
-    render(<FlyerCountDisplay />);
+    renderWithProviders(<FlyerCountDisplay />);
 
     // Assert: Check that the error message is displayed.
     expect(screen.getByRole('alert')).toHaveTextContent(errorMessage);
@@ -73,7 +74,7 @@ describe('FlyerCountDisplay', () => {
     });
 
     // Act
-    render(<FlyerCountDisplay />);
+    renderWithProviders(<FlyerCountDisplay />);
 
     // Assert: Check that the correct count is displayed.
     const countDisplay = screen.getByTestId('flyer-count');

src/components/Footer.test.tsx

@@ -1,8 +1,9 @@
 // src/components/Footer.test.tsx
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { screen } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 import { Footer } from './Footer';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 describe('Footer', () => {
   beforeEach(() => {
@@ -21,7 +22,7 @@ describe('Footer', () => {
     vi.setSystemTime(mockDate);
 
     // Act: Render the component
-    render(<Footer />);
+    renderWithProviders(<Footer />);
 
     // Assert: Check that the rendered text includes the mocked year
     expect(screen.getByText('Copyright 2025-2025')).toBeInTheDocument();
@@ -29,7 +30,7 @@ describe('Footer', () => {
 
   it('should display the correct year when it changes', () => {
     vi.setSystemTime(new Date('2030-01-01T00:00:00Z'));
-    render(<Footer />);
+    renderWithProviders(<Footer />);
     expect(screen.getByText('Copyright 2025-2030')).toBeInTheDocument();
   });
 });

src/components/Header.test.tsx

@@ -1,11 +1,11 @@
 // src/components/Header.test.tsx
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { screen, fireEvent } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { MemoryRouter } from 'react-router-dom';
 import { Header } from './Header';
 import type { UserProfile } from '../types';
 import { createMockUserProfile } from '../tests/utils/mockFactories';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Unmock the component to test the real implementation
 vi.unmock('./Header');
@@ -34,12 +34,8 @@ const defaultProps = {
 };
 
 // Helper to render with router context
-const renderWithRouter = (props: Partial<React.ComponentProps<typeof Header>>) => {
-  return render(
-    <MemoryRouter>
-      <Header {...defaultProps} {...props} />
-    </MemoryRouter>,
-  );
+const renderHeader = (props: Partial<React.ComponentProps<typeof Header>>) => {
+  return renderWithProviders(<Header {...defaultProps} {...props} />);
 };
 
 describe('Header', () => {
@@ -48,30 +44,30 @@ describe('Header', () => {
   });
 
   it('should render the application title', () => {
-    renderWithRouter({});
+    renderHeader({});
     expect(screen.getByRole('heading', { name: /flyer crawler/i })).toBeInTheDocument();
   });
 
   it('should display unit system and theme mode', () => {
-    renderWithRouter({ isDarkMode: true, unitSystem: 'metric' });
+    renderHeader({ isDarkMode: true, unitSystem: 'metric' });
     expect(screen.getByText(/metric/i)).toBeInTheDocument();
     expect(screen.getByText(/dark mode/i)).toBeInTheDocument();
   });
 
   describe('When user is logged out', () => {
     it('should show a Login button', () => {
-      renderWithRouter({ userProfile: null, authStatus: 'SIGNED_OUT' });
+      renderHeader({ userProfile: null, authStatus: 'SIGNED_OUT' });
       expect(screen.getByRole('button', { name: /login/i })).toBeInTheDocument();
     });
 
     it('should call onOpenProfile when Login button is clicked', () => {
-      renderWithRouter({ userProfile: null, authStatus: 'SIGNED_OUT' });
+      renderHeader({ userProfile: null, authStatus: 'SIGNED_OUT' });
       fireEvent.click(screen.getByRole('button', { name: /login/i }));
       expect(mockOnOpenProfile).toHaveBeenCalledTimes(1);
     });
 
     it('should not show user-specific buttons', () => {
-      renderWithRouter({ userProfile: null, authStatus: 'SIGNED_OUT' });
+      renderHeader({ userProfile: null, authStatus: 'SIGNED_OUT' });
       expect(screen.queryByLabelText(/open voice assistant/i)).not.toBeInTheDocument();
       expect(screen.queryByLabelText(/open my account settings/i)).not.toBeInTheDocument();
       expect(screen.queryByRole('button', { name: /logout/i })).not.toBeInTheDocument();
@@ -80,29 +76,29 @@ describe('Header', () => {
 
   describe('When user is authenticated', () => {
     it('should display the user email', () => {
-      renderWithRouter({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
+      renderHeader({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
       expect(screen.getByText(mockUserProfile.user.email)).toBeInTheDocument();
     });
 
     it('should display "Guest" for anonymous users', () => {
-      renderWithRouter({ userProfile: mockUserProfile, authStatus: 'SIGNED_OUT' });
+      renderHeader({ userProfile: mockUserProfile, authStatus: 'SIGNED_OUT' });
       expect(screen.getByText(/guest/i)).toBeInTheDocument();
     });
 
     it('should call onOpenVoiceAssistant when microphone icon is clicked', () => {
-      renderWithRouter({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
+      renderHeader({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
       fireEvent.click(screen.getByLabelText(/open voice assistant/i));
       expect(mockOnOpenVoiceAssistant).toHaveBeenCalledTimes(1);
     });
 
     it('should call onOpenProfile when cog icon is clicked', () => {
-      renderWithRouter({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
+      renderHeader({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
       fireEvent.click(screen.getByLabelText(/open my account settings/i));
       expect(mockOnOpenProfile).toHaveBeenCalledTimes(1);
     });
 
     it('should call onSignOut when Logout button is clicked', () => {
-      renderWithRouter({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
+      renderHeader({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
       fireEvent.click(screen.getByRole('button', { name: /logout/i }));
       expect(mockOnSignOut).toHaveBeenCalledTimes(1);
     });
@@ -110,14 +106,14 @@ describe('Header', () => {
 
   describe('Admin user', () => {
     it('should show the Admin Area link for admin users', () => {
-      renderWithRouter({ userProfile: mockAdminProfile, authStatus: 'AUTHENTICATED' });
+      renderHeader({ userProfile: mockAdminProfile, authStatus: 'AUTHENTICATED' });
       const adminLink = screen.getByTitle(/admin area/i);
       expect(adminLink).toBeInTheDocument();
       expect(adminLink.closest('a')).toHaveAttribute('href', '/admin');
     });
 
     it('should not show the Admin Area link for non-admin users', () => {
-      renderWithRouter({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
+      renderHeader({ userProfile: mockUserProfile, authStatus: 'AUTHENTICATED' });
       expect(screen.queryByTitle(/admin area/i)).not.toBeInTheDocument();
     });
   });

src/components/Leaderboard.test.tsx

@@ -1,12 +1,13 @@
 // src/components/Leaderboard.test.tsx
 import React from 'react';
-import { render, screen, waitFor } from '@testing-library/react';
+import { screen, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, type Mocked } from 'vitest';
 import Leaderboard from './Leaderboard';
 import * as apiClient from '../services/apiClient';
 import { LeaderboardUser } from '../types';
 import { createMockLeaderboardUser } from '../tests/utils/mockFactories';
 import { createMockLogger } from '../tests/utils/mockLogger';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Mock the apiClient
 vi.mock('../services/apiClient'); // This was correct
@@ -45,13 +46,13 @@ describe('Leaderboard', () => {
   it('should display a loading message initially', () => {
     // Mock a pending promise that never resolves to keep it in the loading state
     mockedApiClient.fetchLeaderboard.mockReturnValue(new Promise(() => {}));
-    render(<Leaderboard />);
+    renderWithProviders(<Leaderboard />);
     expect(screen.getByText('Loading Leaderboard...')).toBeInTheDocument();
   });
 
   it('should display an error message if the API call fails', async () => {
     mockedApiClient.fetchLeaderboard.mockResolvedValue(new Response(null, { status: 500 }));
-    render(<Leaderboard />);
+    renderWithProviders(<Leaderboard />);
 
     await waitFor(() => {
       expect(screen.getByRole('alert')).toBeInTheDocument();
@@ -62,7 +63,7 @@ describe('Leaderboard', () => {
   it('should display a generic error for unknown error types', async () => {
     const unknownError = 'A string error';
     mockedApiClient.fetchLeaderboard.mockRejectedValue(unknownError);
-    render(<Leaderboard />);
+    renderWithProviders(<Leaderboard />);
 
     await waitFor(() => {
       expect(screen.getByRole('alert')).toBeInTheDocument();
@@ -72,7 +73,7 @@ describe('Leaderboard', () => {
 
   it('should display a message when the leaderboard is empty', async () => {
     mockedApiClient.fetchLeaderboard.mockResolvedValue(new Response(JSON.stringify([])));
-    render(<Leaderboard />);
+    renderWithProviders(<Leaderboard />);
 
     await waitFor(() => {
       expect(
@@ -85,7 +86,7 @@ describe('Leaderboard', () => {
     mockedApiClient.fetchLeaderboard.mockResolvedValue(
       new Response(JSON.stringify(mockLeaderboardData)),
     );
-    render(<Leaderboard />);
+    renderWithProviders(<Leaderboard />);
 
     await waitFor(() => {
       expect(screen.getByRole('heading', { name: 'Top Users' })).toBeInTheDocument();
@@ -110,7 +111,7 @@ describe('Leaderboard', () => {
     mockedApiClient.fetchLeaderboard.mockResolvedValue(
       new Response(JSON.stringify(mockLeaderboardData)),
     );
-    render(<Leaderboard />);
+    renderWithProviders(<Leaderboard />);
 
     await waitFor(() => {
       // Rank 1, 2, and 3 should have a crown icon
@@ -129,7 +130,7 @@ describe('Leaderboard', () => {
     mockedApiClient.fetchLeaderboard.mockResolvedValue(
       new Response(JSON.stringify(dataWithMissingNames)),
     );
-    render(<Leaderboard />);
+    renderWithProviders(<Leaderboard />);
 
     await waitFor(() => {
       // Check for fallback name

src/components/LoadingSpinner.test.tsx

@@ -1,19 +1,19 @@
 // src/components/LoadingSpinner.test.tsx
 import React from 'react';
-import { render } from '@testing-library/react';
 import { describe, it, expect } from 'vitest';
 import { LoadingSpinner } from './LoadingSpinner';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 describe('LoadingSpinner (in components)', () => {
   it('should render the SVG with animation classes', () => {
-    const { container } = render(<LoadingSpinner />);
+    const { container } = renderWithProviders(<LoadingSpinner />);
     const svgElement = container.querySelector('svg');
     expect(svgElement).toBeInTheDocument();
     expect(svgElement).toHaveClass('animate-spin');
   });
 
   it('should contain the correct SVG paths for the spinner graphic', () => {
-    const { container } = render(<LoadingSpinner />);
+    const { container } = renderWithProviders(<LoadingSpinner />);
     const circle = container.querySelector('circle');
     const path = container.querySelector('path');
     expect(circle).toBeInTheDocument();

src/components/MapView.test.tsx

@@ -1,9 +1,10 @@
 // src/components/MapView.test.tsx
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { screen } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { MapView } from './MapView';
 import config from '../config';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Create a type-safe mocked version of the config for easier manipulation
 const mockedConfig = vi.mocked(config);
@@ -40,14 +41,14 @@ describe('MapView', () => {
 
   describe('when API key is not configured', () => {
     it('should render a disabled message', () => {
-      render(<MapView {...defaultProps} />);
+      renderWithProviders(<MapView {...defaultProps} />);
       expect(
         screen.getByText('Map view is disabled: API key is not configured.'),
       ).toBeInTheDocument();
     });
 
     it('should not render the iframe', () => {
-      render(<MapView {...defaultProps} />);
+      renderWithProviders(<MapView {...defaultProps} />);
       // Use queryByTitle because iframes don't have a default "iframe" role
       expect(screen.queryByTitle('Map view')).not.toBeInTheDocument();
     });
@@ -62,7 +63,7 @@ describe('MapView', () => {
     });
 
     it('should render the iframe with the correct src URL', () => {
-      render(<MapView {...defaultProps} />);
+      renderWithProviders(<MapView {...defaultProps} />);
 
       // Use getByTitle to access the iframe
       const iframe = screen.getByTitle('Map view');

src/components/PasswordInput.test.tsx

@@ -1,8 +1,9 @@
 // src/components/PasswordInput.test.tsx
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { screen, fireEvent } from '@testing-library/react';
 import { describe, it, expect, vi } from 'vitest';
 import { PasswordInput } from './PasswordInput';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 // Mock the child PasswordStrengthIndicator component to isolate the test (relative to new location)
 vi.mock('./PasswordStrengthIndicator', () => ({
   PasswordStrengthIndicator: ({ password }: { password?: string }) => (
@@ -12,13 +13,13 @@ vi.mock('./PasswordStrengthIndicator', () => ({
 
 describe('PasswordInput (in auth feature)', () => {
   it('should render as a password input by default', () => {
-    render(<PasswordInput placeholder="Enter password" />);
+    renderWithProviders(<PasswordInput placeholder="Enter password" />);
     const input = screen.getByPlaceholderText('Enter password');
     expect(input).toHaveAttribute('type', 'password');
   });
 
   it('should toggle input type between password and text when the eye icon is clicked', () => {
-    render(<PasswordInput placeholder="Enter password" />);
+    renderWithProviders(<PasswordInput placeholder="Enter password" />);
     const input = screen.getByPlaceholderText('Enter password');
     const toggleButton = screen.getByRole('button', { name: /show password/i });
 
@@ -38,7 +39,7 @@ describe('PasswordInput (in auth feature)', () => {
 
   it('should pass through standard input attributes', () => {
     const handleChange = vi.fn();
-    render(
+    renderWithProviders(
       <PasswordInput
         value="test"
         onChange={handleChange}
@@ -56,38 +57,38 @@ describe('PasswordInput (in auth feature)', () => {
   });
 
   it('should not show strength indicator by default', () => {
-    render(<PasswordInput value="some-password" onChange={() => {}} />);
+    renderWithProviders(<PasswordInput value="some-password" onChange={() => {}} />);
     expect(screen.queryByTestId('strength-indicator')).not.toBeInTheDocument();
   });
 
   it('should show strength indicator when showStrength is true and there is a value', () => {
-    render(<PasswordInput value="some-password" showStrength onChange={() => {}} />);
+    renderWithProviders(<PasswordInput value="some-password" showStrength onChange={() => {}} />);
     const indicator = screen.getByTestId('strength-indicator');
     expect(indicator).toBeInTheDocument();
     expect(indicator).toHaveTextContent('Strength for: some-password');
   });
 
   it('should not show strength indicator when showStrength is true but value is empty', () => {
-    render(<PasswordInput value="" showStrength onChange={() => {}} />);
+    renderWithProviders(<PasswordInput value="" showStrength onChange={() => {}} />);
     expect(screen.queryByTestId('strength-indicator')).not.toBeInTheDocument();
   });
 
   it('should handle undefined className gracefully', () => {
-    render(<PasswordInput placeholder="No class" />);
+    renderWithProviders(<PasswordInput placeholder="No class" />);
     const input = screen.getByPlaceholderText('No class');
     expect(input.className).not.toContain('undefined');
     expect(input.className).toContain('block w-full');
   });
 
   it('should not show strength indicator if value is undefined', () => {
-    render(<PasswordInput showStrength onChange={() => {}} />);
+    renderWithProviders(<PasswordInput showStrength onChange={() => {}} />);
     expect(screen.queryByTestId('strength-indicator')).not.toBeInTheDocument();
   });
 
   it('should not show strength indicator if value is not a string', () => {
     // Force a non-string value to test the typeof check
     const props = { value: 12345, showStrength: true, onChange: () => {} } as any;
-    render(<PasswordInput {...props} />);
+    renderWithProviders(<PasswordInput {...props} />);
     expect(screen.queryByTestId('strength-indicator')).not.toBeInTheDocument();
   });
 });

src/components/PasswordStrengthIndicator.test.tsx

@@ -1,8 +1,9 @@
 // src/pages/admin/components/PasswordStrengthIndicator.test.tsx
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { screen } from '@testing-library/react';
 import { describe, it, expect, vi, type Mock } from 'vitest';
 import { PasswordStrengthIndicator } from './PasswordStrengthIndicator';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 import zxcvbn from 'zxcvbn';
 
 // Mock the zxcvbn library to control its output for testing
@@ -11,7 +12,7 @@ vi.mock('zxcvbn');
 describe('PasswordStrengthIndicator', () => {
   it('should render 5 gray bars when no password is provided', () => {
     (zxcvbn as Mock).mockReturnValue({ score: -1, feedback: { warning: '', suggestions: [] } });
-    const { container } = render(<PasswordStrengthIndicator password="" />);
+    const { container } = renderWithProviders(<PasswordStrengthIndicator password="" />);
     const bars = container.querySelectorAll('.h-1\\.5');
     expect(bars).toHaveLength(5);
     bars.forEach((bar) => {
@@ -28,7 +29,7 @@ describe('PasswordStrengthIndicator', () => {
     { score: 4, label: 'Strong', color: 'bg-green-500', bars: 5 },
   ])('should render correctly for score $score ($label)', ({ score, label, color, bars }) => {
     (zxcvbn as Mock).mockReturnValue({ score, feedback: { warning: '', suggestions: [] } });
-    const { container } = render(<PasswordStrengthIndicator password="some-password" />);
+    const { container } = renderWithProviders(<PasswordStrengthIndicator password="some-password" />);
 
     // Check the label
     expect(screen.getByText(label)).toBeInTheDocument();
@@ -54,7 +55,7 @@ describe('PasswordStrengthIndicator', () => {
         suggestions: [],
       },
     });
-    render(<PasswordStrengthIndicator password="password" />);
+    renderWithProviders(<PasswordStrengthIndicator password="password" />);
     expect(screen.getByText(/this is a very common password/i)).toBeInTheDocument();
   });
 
@@ -66,7 +67,7 @@ describe('PasswordStrengthIndicator', () => {
         suggestions: ['Add another word or two'],
       },
     });
-    render(<PasswordStrengthIndicator password="pass" />);
+    renderWithProviders(<PasswordStrengthIndicator password="pass" />);
     expect(screen.getByText(/add another word or two/i)).toBeInTheDocument();
   });
 
@@ -75,14 +76,14 @@ describe('PasswordStrengthIndicator', () => {
       score: 1,
       feedback: { warning: 'A warning here', suggestions: ['A suggestion here'] },
     });
-    render(<PasswordStrengthIndicator password="password" />);
+    renderWithProviders(<PasswordStrengthIndicator password="password" />);
     expect(screen.getByText(/a warning here/i)).toBeInTheDocument();
     expect(screen.queryByText(/a suggestion here/i)).not.toBeInTheDocument();
   });
 
   it('should use default empty string if password prop is undefined', () => {
     (zxcvbn as Mock).mockReturnValue({ score: 0, feedback: { warning: '', suggestions: [] } });
-    const { container } = render(<PasswordStrengthIndicator />);
+    const { container } = renderWithProviders(<PasswordStrengthIndicator />);
     const bars = container.querySelectorAll('.h-1\\.5');
     expect(bars).toHaveLength(5);
     bars.forEach((bar) => {
@@ -94,7 +95,7 @@ describe('PasswordStrengthIndicator', () => {
   it('should handle out-of-range scores gracefully (defensive)', () => {
     // Mock a score that isn't 0-4 to hit default switch cases
     (zxcvbn as Mock).mockReturnValue({ score: 99, feedback: { warning: '', suggestions: [] } });
-    const { container } = render(<PasswordStrengthIndicator password="test" />);
+    const { container } = renderWithProviders(<PasswordStrengthIndicator password="test" />);
 
     // Check bars - should hit default case in getBarColor which returns gray
     const bars = container.querySelectorAll('.h-1\\.5');

src/components/RecipeSuggester.test.tsx

@@ -0,0 +1,164 @@
+// src/components/RecipeSuggester.test.tsx
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { RecipeSuggester } from './RecipeSuggester';
+import { suggestRecipe } from '../services/apiClient';
+import { logger } from '../services/logger.client';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
+import '@testing-library/jest-dom';
+
+// Mock the API client
+vi.mock('../services/apiClient', () => ({
+  suggestRecipe: vi.fn(),
+}));
+
+// Mock the logger
+vi.mock('../services/logger.client', () => ({
+  logger: {
+    error: vi.fn(),
+  },
+}));
+
+describe('RecipeSuggester Component', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Reset console logs if needed, or just keep them for debug visibility
+  });
+
+  it('renders correctly with initial state', () => {
+    console.log('TEST: Verifying initial render state');
+    renderWithProviders(<RecipeSuggester />);
+
+    expect(screen.getByText('Get a Recipe Suggestion')).toBeInTheDocument();
+    expect(screen.getByLabelText(/Ingredients:/i)).toBeInTheDocument();
+    expect(screen.getByRole('button', { name: /Suggest a Recipe/i })).toBeInTheDocument();
+    expect(screen.queryByText('Getting suggestion...')).not.toBeInTheDocument();
+  });
+
+  it('shows validation error if no ingredients are entered', async () => {
+    console.log('TEST: Verifying validation for empty input');
+    const user = userEvent.setup();
+    renderWithProviders(<RecipeSuggester />);
+
+    const button = screen.getByRole('button', { name: /Suggest a Recipe/i });
+    await user.click(button);
+
+    expect(await screen.findByText('Please enter at least one ingredient.')).toBeInTheDocument();
+    expect(suggestRecipe).not.toHaveBeenCalled();
+    console.log('TEST: Validation error displayed correctly');
+  });
+
+  it('calls suggestRecipe and displays suggestion on success', async () => {
+    console.log('TEST: Verifying successful recipe suggestion flow');
+    const user = userEvent.setup();
+    renderWithProviders(<RecipeSuggester />);
+
+    const input = screen.getByLabelText(/Ingredients:/i);
+    await user.type(input, 'chicken, rice');
+
+    // Mock successful API response
+    const mockSuggestion = 'Here is a nice Chicken and Rice recipe...';
+    // Add a delay to ensure the loading state is visible during the test
+    vi.mocked(suggestRecipe).mockImplementation(async () => {
+      await new Promise((resolve) => setTimeout(resolve, 50));
+      return { ok: true, json: async () => ({ suggestion: mockSuggestion }) } as Response;
+    });
+
+    const button = screen.getByRole('button', { name: /Suggest a Recipe/i });
+    await user.click(button);
+
+    // Check loading state
+    expect(screen.getByRole('button')).toBeDisabled();
+    expect(screen.getByText('Getting suggestion...')).toBeInTheDocument();
+
+    await waitFor(() => {
+      expect(screen.getByText(mockSuggestion)).toBeInTheDocument();
+    });
+
+    expect(suggestRecipe).toHaveBeenCalledWith(['chicken', 'rice']);
+    console.log('TEST: Suggestion displayed and API called with correct args');
+  });
+
+  it('handles API errors (non-200 response) gracefully', async () => {
+    console.log('TEST: Verifying API error handling (400/500 responses)');
+    const user = userEvent.setup();
+    renderWithProviders(<RecipeSuggester />);
+
+    const input = screen.getByLabelText(/Ingredients:/i);
+    await user.type(input, 'rocks');
+
+    // Mock API failure response
+    const errorMessage = 'Invalid ingredients provided.';
+    vi.mocked(suggestRecipe).mockResolvedValue({
+      ok: false,
+      json: async () => ({ message: errorMessage }),
+    } as Response);
+
+    const button = screen.getByRole('button', { name: /Suggest a Recipe/i });
+    await user.click(button);
+
+    await waitFor(() => {
+      expect(screen.getByText(errorMessage)).toBeInTheDocument();
+    });
+
+    // Ensure loading state is reset
+    expect(screen.getByRole('button', { name: /Suggest a Recipe/i })).toBeEnabled();
+    console.log('TEST: API error message displayed to user');
+  });
+
+  it('handles network exceptions and logs them', async () => {
+    console.log('TEST: Verifying network exception handling');
+    const user = userEvent.setup();
+    renderWithProviders(<RecipeSuggester />);
+
+    const input = screen.getByLabelText(/Ingredients:/i);
+    await user.type(input, 'beef');
+
+    // Mock network error
+    const networkError = new Error('Network Error');
+    vi.mocked(suggestRecipe).mockRejectedValue(networkError);
+
+    const button = screen.getByRole('button', { name: /Suggest a Recipe/i });
+    await user.click(button);
+
+    await waitFor(() => {
+      expect(screen.getByText('Network Error')).toBeInTheDocument();
+    });
+
+    expect(logger.error).toHaveBeenCalledWith(
+      { error: networkError },
+      'Failed to fetch recipe suggestion.'
+    );
+    console.log('TEST: Network error caught and logged');
+  });
+
+  it('clears previous errors when submitting again', async () => {
+    console.log('TEST: Verifying error clearing on re-submit');
+    const user = userEvent.setup();
+    renderWithProviders(<RecipeSuggester />);
+
+    // Trigger validation error first
+    const button = screen.getByRole('button', { name: /Suggest a Recipe/i });
+    await user.click(button);
+    expect(screen.getByText('Please enter at least one ingredient.')).toBeInTheDocument();
+
+    // Now type something to clear it (state change doesn't clear it, submit does)
+    const input = screen.getByLabelText(/Ingredients:/i);
+    await user.type(input, 'tofu');
+
+    // Mock success for the second click
+    vi.mocked(suggestRecipe).mockResolvedValue({
+      ok: true,
+      json: async () => ({ suggestion: 'Tofu Stir Fry' }),
+    } as Response);
+
+    await user.click(button);
+
+    await waitFor(() => {
+      expect(screen.queryByText('Please enter at least one ingredient.')).not.toBeInTheDocument();
+      expect(screen.getByText('Tofu Stir Fry')).toBeInTheDocument();
+    });
+    console.log('TEST: Previous error cleared successfully');
+  });
+});

src/components/RecipeSuggester.tsx

@@ -0,0 +1,80 @@
+// src/components/RecipeSuggester.tsx
+import React, { useState, useCallback } from 'react';
+import { suggestRecipe } from '../services/apiClient';
+import { logger } from '../services/logger.client';
+
+export const RecipeSuggester: React.FC = () => {
+  const [ingredients, setIngredients] = useState<string>('');
+  const [suggestion, setSuggestion] = useState<string | null>(null);
+  const [isLoading, setIsLoading] = useState<boolean>(false);
+  const [error, setError] = useState<string | null>(null);
+
+  const handleSubmit = useCallback(async (event: React.FormEvent<HTMLFormElement>) => {
+    event.preventDefault();
+    setIsLoading(true);
+    setError(null);
+    setSuggestion(null);
+
+    const ingredientList = ingredients.split(',').map(item => item.trim()).filter(Boolean);
+
+    if (ingredientList.length === 0) {
+      setError('Please enter at least one ingredient.');
+      setIsLoading(false);
+      return;
+    }
+
+    try {
+      const response = await suggestRecipe(ingredientList);
+      const data = await response.json();
+
+      if (!response.ok) {
+        throw new Error(data.message || 'Failed to get suggestion.');
+      }
+
+      setSuggestion(data.suggestion);
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : 'An unknown error occurred.';
+      logger.error({ error: err }, 'Failed to fetch recipe suggestion.');
+      setError(errorMessage);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [ingredients]);
+
+  return (
+    <div className="bg-white dark:bg-gray-800 shadow rounded-lg p-6">
+      <h2 className="text-xl font-semibold text-gray-900 dark:text-white mb-2">Get a Recipe Suggestion</h2>
+      <p className="text-gray-600 dark:text-gray-400 mb-4">Enter some ingredients you have, separated by commas.</p>
+      <form onSubmit={handleSubmit}>
+        <div className="mb-4">
+          <label htmlFor="ingredients-input" className="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-1">Ingredients:</label>
+          <input
+            id="ingredients-input"
+            type="text"
+            value={ingredients}
+            onChange={(e) => setIngredients(e.target.value)}
+            placeholder="e.g., chicken, rice, broccoli"
+            disabled={isLoading}
+            className="block w-full rounded-md border-gray-300 shadow-sm focus:border-blue-500 focus:ring-blue-500 dark:bg-gray-700 dark:border-gray-600 dark:text-white sm:text-sm p-2 border"
+          />
+        </div>
+        <button type="submit" disabled={isLoading} className="w-full flex justify-center py-2 px-4 border border-transparent rounded-md shadow-sm text-sm font-medium text-white bg-blue-600 hover:bg-blue-700 focus:outline-none focus:ring-2 focus:ring-offset-2 focus:ring-blue-500 disabled:opacity-50 transition-colors">
+          {isLoading ? 'Getting suggestion...' : 'Suggest a Recipe'}
+        </button>
+      </form>
+
+      {error && (
+        <div className="mt-4 p-4 bg-red-50 dark:bg-red-900/50 text-red-700 dark:text-red-200 rounded-md text-sm">{error}</div>
+      )}
+
+      {suggestion && (
+        <div className="mt-6 bg-gray-50 dark:bg-gray-700/50 rounded-lg p-4 border border-gray-200 dark:border-gray-600">
+          <div className="prose dark:prose-invert max-w-none">
+            <h5 className="text-lg font-medium text-gray-900 dark:text-white mb-2">Recipe Suggestion</h5>
+            <p className="text-gray-700 dark:text-gray-300 whitespace-pre-wrap">{suggestion}</p>
+          </div>
+        </div>
+      )}
+    </div>
+  );
+};

src/components/StatCard.test.tsx

@@ -0,0 +1,34 @@
+// src/components/StatCard.test.tsx
+import React from 'react';
+import { screen } from '@testing-library/react';
+import { describe, it, expect } from 'vitest';
+import { StatCard } from './StatCard';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
+import '@testing-library/jest-dom';
+
+describe('StatCard', () => {
+  it('renders title and value correctly', () => {
+    renderWithProviders(
+      <StatCard
+        title="Total Users"
+        value="1,234"
+        icon={<div data-testid="mock-icon">Icon</div>}
+      />,
+    );
+
+    expect(screen.getByText('Total Users')).toBeInTheDocument();
+    expect(screen.getByText('1,234')).toBeInTheDocument();
+  });
+
+  it('renders the icon', () => {
+    renderWithProviders(
+      <StatCard
+        title="Total Users"
+        value="1,234"
+        icon={<div data-testid="mock-icon">Icon</div>}
+      />,
+    );
+
+    expect(screen.getByTestId('mock-icon')).toBeInTheDocument();
+  });
+});

src/components/StatCard.tsx

@@ -0,0 +1,32 @@
+// src/components/StatCard.tsx
+import React, { ReactNode } from 'react';
+
+interface StatCardProps {
+  title: string;
+  value: string;
+  icon: ReactNode;
+}
+
+export const StatCard: React.FC<StatCardProps> = ({ title, value, icon }) => {
+  return (
+    <div className="bg-white dark:bg-gray-800 overflow-hidden shadow rounded-lg">
+      <div className="p-5">
+        <div className="flex items-center">
+          <div className="flex-shrink-0">
+            <div className="flex items-center justify-center h-12 w-12 rounded-md bg-blue-500 text-white">
+              {icon}
+            </div>
+          </div>
+          <div className="ml-5 w-0 flex-1">
+            <dl>
+              <dt className="text-sm font-medium text-gray-500 dark:text-gray-400 truncate">{title}</dt>
+              <dd>
+                <div className="text-lg font-medium text-gray-900 dark:text-white">{value}</div>
+              </dd>
+            </dl>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};

src/components/UnitSystemToggle.test.tsx

@@ -1,8 +1,9 @@
 // src/components/UnitSystemToggle.test.tsx
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { screen, fireEvent } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { UnitSystemToggle } from './UnitSystemToggle';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 describe('UnitSystemToggle', () => {
   const mockOnToggle = vi.fn();
@@ -12,7 +13,7 @@ describe('UnitSystemToggle', () => {
   });
 
   it('should render correctly for imperial system', () => {
-    render(<UnitSystemToggle currentSystem="imperial" onToggle={mockOnToggle} />);
+    renderWithProviders(<UnitSystemToggle currentSystem="imperial" onToggle={mockOnToggle} />);
 
     const checkbox = screen.getByRole('checkbox');
     expect(checkbox).toBeChecked();
@@ -23,7 +24,7 @@ describe('UnitSystemToggle', () => {
   });
 
   it('should render correctly for metric system', () => {
-    render(<UnitSystemToggle currentSystem="metric" onToggle={mockOnToggle} />);
+    renderWithProviders(<UnitSystemToggle currentSystem="metric" onToggle={mockOnToggle} />);
 
     const checkbox = screen.getByRole('checkbox');
     expect(checkbox).not.toBeChecked();
@@ -34,7 +35,7 @@ describe('UnitSystemToggle', () => {
   });
 
   it('should call onToggle when the toggle is clicked', () => {
-    render(<UnitSystemToggle currentSystem="metric" onToggle={mockOnToggle} />);
+    renderWithProviders(<UnitSystemToggle currentSystem="metric" onToggle={mockOnToggle} />);
     fireEvent.click(screen.getByRole('checkbox'));
     expect(mockOnToggle).toHaveBeenCalledTimes(1);
   });

src/components/UserMenuSkeleton.test.tsx

@@ -1,34 +1,34 @@
 // src/components/UserMenuSkeleton.test.tsx
 import React from 'react';
-import { render } from '@testing-library/react';
 import { describe, it, expect } from 'vitest';
 import { UserMenuSkeleton } from './UserMenuSkeleton';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 describe('UserMenuSkeleton', () => {
   it('should render without crashing', () => {
-    const { container } = render(<UserMenuSkeleton />);
+    const { container } = renderWithProviders(<UserMenuSkeleton />);
     expect(container.firstChild).toBeInTheDocument();
   });
 
   it('should have the main container with pulse animation', () => {
-    const { container } = render(<UserMenuSkeleton />);
+    const { container } = renderWithProviders(<UserMenuSkeleton />);
     expect(container.firstChild).toHaveClass('animate-pulse');
   });
 
   it('should render two child placeholder elements', () => {
-    const { container } = render(<UserMenuSkeleton />);
+    const { container } = renderWithProviders(<UserMenuSkeleton />);
     expect(container.firstChild?.childNodes.length).toBe(2);
   });
 
   it('should render a rectangular placeholder with correct styles', () => {
-    const { container } = render(<UserMenuSkeleton />);
+    const { container } = renderWithProviders(<UserMenuSkeleton />);
     expect(container.querySelector('.rounded-md')).toHaveClass(
       'h-8 w-24 bg-gray-200 dark:bg-gray-700',
     );
   });
 
   it('should render a circular placeholder with correct styles', () => {
-    const { container } = render(<UserMenuSkeleton />);
+    const { container } = renderWithProviders(<UserMenuSkeleton />);
     expect(container.querySelector('.rounded-full')).toHaveClass(
       'h-10 w-10 bg-gray-200 dark:bg-gray-700',
     );

src/components/WhatsNewModal.test.tsx

@@ -1,8 +1,9 @@
 // src/components/WhatsNewModal.test.tsx
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { screen, fireEvent } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { WhatsNewModal } from './WhatsNewModal';
+import { renderWithProviders } from '../tests/utils/renderWithProviders';
 
 // Unmock the component to test the real implementation
 vi.unmock('./WhatsNewModal');
@@ -21,13 +22,13 @@ describe('WhatsNewModal', () => {
   });
 
   it('should not render when isOpen is false', () => {
-    const { container } = render(<WhatsNewModal {...defaultProps} isOpen={false} />);
+    const { container } = renderWithProviders(<WhatsNewModal {...defaultProps} isOpen={false} />);
     // The component returns null, so the container should be empty.
     expect(container.firstChild).toBeNull();
   });
 
   it('should render correctly when isOpen is true', () => {
-    render(<WhatsNewModal {...defaultProps} />);
+    renderWithProviders(<WhatsNewModal {...defaultProps} />);
 
     expect(screen.getByRole('heading', { name: /what's new/i })).toBeInTheDocument();
     expect(screen.getByText(`Version: ${defaultProps.version}`)).toBeInTheDocument();
@@ -36,13 +37,13 @@ describe('WhatsNewModal', () => {
   });
 
   it('should call onClose when the "Got it!" button is clicked', () => {
-    render(<WhatsNewModal {...defaultProps} />);
+    renderWithProviders(<WhatsNewModal {...defaultProps} />);
     fireEvent.click(screen.getByRole('button', { name: /got it/i }));
     expect(mockOnClose).toHaveBeenCalledTimes(1);
   });
 
   it('should call onClose when the close icon button is clicked', () => {
-    render(<WhatsNewModal {...defaultProps} />);
+    renderWithProviders(<WhatsNewModal {...defaultProps} />);
     // The close button is an SVG icon inside a button, best queried by its aria-label.
     const closeButton = screen.getByRole('button', { name: /close/i });
     fireEvent.click(closeButton);
@@ -50,7 +51,7 @@ describe('WhatsNewModal', () => {
   });
 
   it('should call onClose when clicking on the overlay', () => {
-    render(<WhatsNewModal {...defaultProps} />);
+    renderWithProviders(<WhatsNewModal {...defaultProps} />);
     // The overlay is the root div with the background color.
     const overlay = screen.getByRole('dialog').parentElement;
     fireEvent.click(overlay!);
@@ -58,7 +59,7 @@ describe('WhatsNewModal', () => {
   });
 
   it('should not call onClose when clicking inside the modal content', () => {
-    render(<WhatsNewModal {...defaultProps} />);
+    renderWithProviders(<WhatsNewModal {...defaultProps} />);
     fireEvent.click(screen.getByText(defaultProps.commitMessage));
     expect(mockOnClose).not.toHaveBeenCalled();
   });

src/db/seed.ts

@@ -111,7 +111,7 @@ async function main() {
 
     const flyerQuery = `
         INSERT INTO public.flyers (file_name, image_url, checksum, store_id, valid_from, valid_to)
-        VALUES ('safeway-flyer.jpg', '/sample-assets/safeway-flyer.jpg', 'sample-checksum-123', ${storeMap.get('Safeway')}, $1, $2)
+        VALUES ('safeway-flyer.jpg', 'https://example.com/flyer-images/safeway-flyer.jpg', 'a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0a0', ${storeMap.get('Safeway')}, $1, $2)
         RETURNING flyer_id;
     `;
     const flyerRes = await client.query<{ flyer_id: number }>(flyerQuery, [

src/pages/admin/AdminStatsPage.test.tsx

@@ -7,13 +7,13 @@ import { AdminStatsPage } from './AdminStatsPage';
 import * as apiClient from '../../services/apiClient';
 import type { AppStats } from '../../services/apiClient';
 import { createMockAppStats } from '../../tests/utils/mockFactories';
-import { StatCard } from './components/StatCard';
+import { StatCard } from '../../components/StatCard';
 
 // The apiClient and logger are now mocked globally via src/tests/setup/tests-setup-unit.ts.
 const mockedApiClient = vi.mocked(apiClient);
 
 // Mock the child StatCard component to use the shared mock and allow spying
-vi.mock('./components/StatCard', async () => {
+vi.mock('../../components/StatCard', async () => {
   const { MockStatCard } = await import('../../tests/utils/componentMocks');
   return { StatCard: vi.fn(MockStatCard) };
 });

src/pages/admin/AdminStatsPage.tsx

@@ -10,7 +10,7 @@ import { DocumentDuplicateIcon } from '../../components/icons/DocumentDuplicateI
 import { BuildingStorefrontIcon } from '../../components/icons/BuildingStorefrontIcon';
 import { BellAlertIcon } from '../../components/icons/BellAlertIcon';
 import { BookOpenIcon } from '../../components/icons/BookOpenIcon';
-import { StatCard } from './components/StatCard';
+import { StatCard } from '../../components/StatCard';
 
 export const AdminStatsPage: React.FC = () => {
   const [stats, setStats] = useState<AppStats | null>(null);

src/pages/admin/components/AddressForm.test.tsx

@@ -1,9 +1,10 @@
 // src/pages/admin/components/AddressForm.test.tsx
 import React from 'react';
-import { render, screen, fireEvent } from '@testing-library/react';
+import { screen, fireEvent } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import { AddressForm } from './AddressForm';
 import { createMockAddress } from '../../../tests/utils/mockFactories';
+import { renderWithProviders } from '../../../tests/utils/renderWithProviders';
 
 // Mock child components and icons to isolate the form's logic
 vi.mock('lucide-react', () => ({
@@ -30,7 +31,7 @@ describe('AddressForm', () => {
   });
 
   it('should render all address fields correctly', () => {
-    render(<AddressForm {...defaultProps} />);
+    renderWithProviders(<AddressForm {...defaultProps} />);
 
     expect(screen.getByRole('heading', { name: /home address/i })).toBeInTheDocument();
     expect(screen.getByLabelText(/address line 1/i)).toBeInTheDocument();
@@ -48,7 +49,7 @@ describe('AddressForm', () => {
       city: 'Anytown',
       country: 'Canada',
     });
-    render(<AddressForm {...defaultProps} address={fullAddress} />);
+    renderWithProviders(<AddressForm {...defaultProps} address={fullAddress} />);
 
     expect(screen.getByLabelText(/address line 1/i)).toHaveValue('123 Main St');
     expect(screen.getByLabelText(/city/i)).toHaveValue('Anytown');
@@ -56,7 +57,7 @@ describe('AddressForm', () => {
   });
 
   it('should call onAddressChange with the correct field and value for all inputs', () => {
-    render(<AddressForm {...defaultProps} />);
+    renderWithProviders(<AddressForm {...defaultProps} />);
 
     const inputs = [
       { label: /address line 1/i, name: 'address_line_1', value: '123 St' },
@@ -75,7 +76,7 @@ describe('AddressForm', () => {
   });
 
   it('should call onGeocode when the "Re-Geocode" button is clicked', () => {
-    render(<AddressForm {...defaultProps} />);
+    renderWithProviders(<AddressForm {...defaultProps} />);
 
     const geocodeButton = screen.getByRole('button', { name: /re-geocode/i });
     fireEvent.click(geocodeButton);
@@ -84,14 +85,14 @@ describe('AddressForm', () => {
   });
 
   it('should show MapPinIcon when not geocoding', () => {
-    render(<AddressForm {...defaultProps} isGeocoding={false} />);
+    renderWithProviders(<AddressForm {...defaultProps} isGeocoding={false} />);
     expect(screen.getByTestId('map-pin-icon')).toBeInTheDocument();
     expect(screen.queryByTestId('loading-spinner')).not.toBeInTheDocument();
   });
 
   describe('when isGeocoding is true', () => {
     it('should disable the button and show a loading spinner', () => {
-      render(<AddressForm {...defaultProps} isGeocoding={true} />);
+      renderWithProviders(<AddressForm {...defaultProps} isGeocoding={true} />);
 
       const geocodeButton = screen.getByRole('button', { name: /re-geocode/i });
       expect(geocodeButton).toBeDisabled();

src/pages/admin/components/AdminBrandManager.test.tsx

@@ -1,11 +1,12 @@
 // src/pages/admin/components/AdminBrandManager.test.tsx
 import React from 'react';
-import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { screen, fireEvent, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach } from 'vitest';
 import toast from 'react-hot-toast';
 import { AdminBrandManager } from './AdminBrandManager';
 import * as apiClient from '../../../services/apiClient';
 import { createMockBrand } from '../../../tests/utils/mockFactories';
+import { renderWithProviders } from '../../../tests/utils/renderWithProviders';
 
 // After mocking, we can get a type-safe mocked version of the module.
 // This allows us to use .mockResolvedValue, .mockRejectedValue, etc. on the functions.
@@ -34,7 +35,7 @@ describe('AdminBrandManager', () => {
     mockedApiClient.fetchAllBrands.mockReturnValue(new Promise(() => {}));
 
     console.log('TEST ACTION: Rendering AdminBrandManager component.');
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
 
     console.log('TEST ASSERTION: Checking for the loading text.');
     expect(screen.getByText('Loading brands...')).toBeInTheDocument();
@@ -49,7 +50,7 @@ describe('AdminBrandManager', () => {
     mockedApiClient.fetchAllBrands.mockRejectedValue(new Error('Network Error'));
 
     console.log('TEST ACTION: Rendering AdminBrandManager component.');
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
 
     console.log('TEST ASSERTION: Waiting for error message to be displayed.');
     await waitFor(() => {
@@ -69,7 +70,7 @@ describe('AdminBrandManager', () => {
     );
 
     console.log('TEST ACTION: Rendering AdminBrandManager component.');
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
 
     console.log('TEST ASSERTION: Waiting for brand list to render.');
     await waitFor(() => {
@@ -98,7 +99,7 @@ describe('AdminBrandManager', () => {
     mockedToast.loading.mockReturnValue('toast-1');
 
     console.log('TEST ACTION: Rendering AdminBrandManager component.');
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     console.log('TEST ACTION: Waiting for initial brands to render.');
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
@@ -135,7 +136,7 @@ describe('AdminBrandManager', () => {
     mockedApiClient.uploadBrandLogo.mockRejectedValue('A string error');
     mockedToast.loading.mockReturnValue('toast-non-error');
 
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
     const file = new File(['logo'], 'logo.png', { type: 'image/png' });
@@ -162,7 +163,7 @@ describe('AdminBrandManager', () => {
     mockedToast.loading.mockReturnValue('toast-2');
 
     console.log('TEST ACTION: Rendering AdminBrandManager component.');
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     console.log('TEST ACTION: Waiting for initial brands to render.');
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
@@ -189,7 +190,7 @@ describe('AdminBrandManager', () => {
       async () => new Response(JSON.stringify(mockBrands), { status: 200 }),
     );
     console.log('TEST ACTION: Rendering AdminBrandManager component.');
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     console.log('TEST ACTION: Waiting for initial brands to render.');
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
@@ -217,7 +218,7 @@ describe('AdminBrandManager', () => {
       async () => new Response(JSON.stringify(mockBrands), { status: 200 }),
     );
     console.log('TEST ACTION: Rendering AdminBrandManager component.');
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     console.log('TEST ACTION: Waiting for initial brands to render.');
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
@@ -247,7 +248,7 @@ describe('AdminBrandManager', () => {
     );
     mockedToast.loading.mockReturnValue('toast-3');
 
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
     const file = new File(['logo'], 'logo.png', { type: 'image/png' });
@@ -270,7 +271,7 @@ describe('AdminBrandManager', () => {
     mockedApiClient.fetchAllBrands.mockImplementation(
       async () => new Response(JSON.stringify(mockBrands), { status: 200 }),
     );
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     console.log('TEST ACTION: Waiting for initial brands to render.');
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
@@ -291,7 +292,7 @@ describe('AdminBrandManager', () => {
     mockedApiClient.fetchAllBrands.mockImplementation(
       async () => new Response(JSON.stringify([]), { status: 200 }),
     );
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
 
     await waitFor(() => {
       expect(screen.getByRole('heading', { name: /brand management/i })).toBeInTheDocument();
@@ -309,7 +310,7 @@ describe('AdminBrandManager', () => {
     );
     mockedToast.loading.mockReturnValue('toast-fallback');
 
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
     const file = new File(['logo'], 'logo.png', { type: 'image/png' });
@@ -333,7 +334,7 @@ describe('AdminBrandManager', () => {
     );
     mockedToast.loading.mockReturnValue('toast-opt');
 
-    render(<AdminBrandManager />);
+    renderWithProviders(<AdminBrandManager />);
     await waitFor(() => expect(screen.getByText('No Frills')).toBeInTheDocument());
 
     // Brand 1: No Frills (initially null logo)

src/pages/admin/components/AuthView.test.tsx

@@ -1,11 +1,12 @@
 // src/pages/admin/components/AuthView.test.tsx
 import React from 'react';
-import { render, screen, fireEvent, waitFor, act } from '@testing-library/react';
+import { screen, fireEvent, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, type Mock } from 'vitest';
 import { AuthView } from './AuthView';
 import * as apiClient from '../../../services/apiClient';
 import { notifySuccess, notifyError } from '../../../services/notificationService';
 import { createMockUserProfile } from '../../../tests/utils/mockFactories';
+import { renderWithProviders } from '../../../tests/utils/renderWithProviders';
 
 const mockedApiClient = vi.mocked(apiClient, true);
 
@@ -46,7 +47,7 @@ describe('AuthView', () => {
 
   describe('Initial Render and Login', () => {
     it('should render the Sign In form by default', () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       expect(screen.getByRole('heading', { name: /sign in/i })).toBeInTheDocument();
       expect(screen.getByLabelText(/email address/i)).toBeInTheDocument();
       expect(screen.getByLabelText(/^password$/i)).toBeInTheDocument();
@@ -54,7 +55,7 @@ describe('AuthView', () => {
     });
 
     it('should allow typing in email and password fields', () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       const emailInput = screen.getByLabelText(/email address/i);
       const passwordInput = screen.getByLabelText(/^password$/i);
 
@@ -66,7 +67,7 @@ describe('AuthView', () => {
     });
 
     it('should call loginUser and onLoginSuccess on successful login', async () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.change(screen.getByLabelText(/email address/i), {
         target: { value: 'test@example.com' },
       });
@@ -94,7 +95,7 @@ describe('AuthView', () => {
 
     it('should display an error on failed login', async () => {
       (mockedApiClient.loginUser as Mock).mockRejectedValueOnce(new Error('Invalid credentials'));
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.submit(screen.getByTestId('auth-form'));
 
       await waitFor(() => {
@@ -107,7 +108,7 @@ describe('AuthView', () => {
       (mockedApiClient.loginUser as Mock).mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'Unauthorized' }), { status: 401 }),
       );
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.submit(screen.getByTestId('auth-form'));
 
       await waitFor(() => {
@@ -120,7 +121,7 @@ describe('AuthView', () => {
 
   describe('Registration', () => {
     it('should switch to the registration form', () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /don't have an account\? register/i }));
 
       expect(screen.getByRole('heading', { name: /create an account/i })).toBeInTheDocument();
@@ -129,7 +130,7 @@ describe('AuthView', () => {
     });
 
     it('should call registerUser on successful registration', async () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /don't have an account\? register/i }));
 
       fireEvent.change(screen.getByLabelText(/full name/i), { target: { value: 'Test User' } });
@@ -157,7 +158,7 @@ describe('AuthView', () => {
     });
 
     it('should allow registration without providing a full name', async () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /don't have an account\? register/i }));
 
       // Do not fill in the full name, which is marked as optional
@@ -184,7 +185,7 @@ describe('AuthView', () => {
       (mockedApiClient.registerUser as Mock).mockRejectedValueOnce(
         new Error('Email already exists'),
       );
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /don't have an account\? register/i }));
       fireEvent.submit(screen.getByTestId('auth-form'));
 
@@ -197,7 +198,7 @@ describe('AuthView', () => {
       (mockedApiClient.registerUser as Mock).mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'User exists' }), { status: 409 }),
       );
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /don't have an account\? register/i }));
       fireEvent.submit(screen.getByTestId('auth-form'));
 
@@ -209,7 +210,7 @@ describe('AuthView', () => {
 
   describe('Forgot Password', () => {
     it('should switch to the reset password form', () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /forgot password\?/i }));
 
       expect(screen.getByRole('heading', { name: /reset password/i })).toBeInTheDocument();
@@ -217,7 +218,7 @@ describe('AuthView', () => {
     });
 
     it('should call requestPasswordReset and show success message', async () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /forgot password\?/i }));
 
       fireEvent.change(screen.getByLabelText(/email address/i), {
@@ -238,7 +239,7 @@ describe('AuthView', () => {
       (mockedApiClient.requestPasswordReset as Mock).mockRejectedValueOnce(
         new Error('User not found'),
       );
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /forgot password\?/i }));
       fireEvent.submit(screen.getByTestId('reset-password-form'));
 
@@ -251,7 +252,7 @@ describe('AuthView', () => {
       (mockedApiClient.requestPasswordReset as Mock).mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'Rate limit exceeded' }), { status: 429 }),
       );
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /forgot password\?/i }));
       fireEvent.submit(screen.getByTestId('reset-password-form'));
 
@@ -261,7 +262,7 @@ describe('AuthView', () => {
     });
 
     it('should switch back to sign in from forgot password', () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /forgot password\?/i }));
       fireEvent.click(screen.getByRole('button', { name: /back to sign in/i }));
 
@@ -287,13 +288,13 @@ describe('AuthView', () => {
     });
 
     it('should set window.location.href for Google OAuth', () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /sign in with google/i }));
       expect(window.location.href).toBe('/api/auth/google');
     });
 
     it('should set window.location.href for GitHub OAuth', () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       fireEvent.click(screen.getByRole('button', { name: /sign in with github/i }));
       expect(window.location.href).toBe('/api/auth/github');
     });
@@ -301,7 +302,7 @@ describe('AuthView', () => {
 
   describe('UI Logic and Loading States', () => {
     it('should toggle "Remember me" checkbox', () => {
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
       const rememberMeCheckbox = screen.getByRole('checkbox', { name: /remember me/i });
 
       expect(rememberMeCheckbox).not.toBeChecked();
@@ -316,7 +317,7 @@ describe('AuthView', () => {
     it('should show loading state during login submission', async () => {
       // Mock a promise that doesn't resolve immediately
       (mockedApiClient.loginUser as Mock).mockReturnValue(new Promise(() => {}));
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
 
       fireEvent.change(screen.getByLabelText(/email address/i), {
         target: { value: 'test@example.com' },
@@ -341,7 +342,7 @@ describe('AuthView', () => {
 
     it('should show loading state during password reset submission', async () => {
       (mockedApiClient.requestPasswordReset as Mock).mockReturnValue(new Promise(() => {}));
-      render(<AuthView {...defaultProps} />);
+      renderWithProviders(<AuthView {...defaultProps} />);
 
       fireEvent.click(screen.getByRole('button', { name: /forgot password\?/i }));
 
@@ -362,7 +363,7 @@ describe('AuthView', () => {
   it('should show loading state during registration submission', async () => {
     // Mock a promise that doesn't resolve immediately
     (mockedApiClient.registerUser as Mock).mockReturnValue(new Promise(() => {}));
-    render(<AuthView {...defaultProps} />);
+    renderWithProviders(<AuthView {...defaultProps} />);
 
     // Switch to registration view
     fireEvent.click(screen.getByRole('button', { name: /don't have an account\? register/i }));

src/pages/admin/components/CorrectionRow.test.tsx

@@ -1,7 +1,7 @@
 // src/pages/admin/components/CorrectionRow.test.tsx
 import React from 'react';
 import ReactDOM from 'react-dom';
-import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { screen, fireEvent, waitFor } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, type Mocked } from 'vitest';
 import { CorrectionRow } from './CorrectionRow';
 import * as apiClient from '../../../services/apiClient';
@@ -10,6 +10,7 @@ import {
   createMockMasterGroceryItem,
   createMockCategory,
 } from '../../../tests/utils/mockFactories';
+import { renderWithProviders } from '../../../tests/utils/renderWithProviders';
 
 // Cast the mocked module to its mocked type to retain type safety and autocompletion.
 // The apiClient is now mocked globally via src/tests/setup/tests-setup-unit.ts.
@@ -80,7 +81,7 @@ const defaultProps = {
 
 // Helper to render the component inside a table structure
 const renderInTable = (props = defaultProps) => {
-  return render(
+  return renderWithProviders(
     <table>
       <tbody>
         <CorrectionRow {...props} />

src/pages/admin/components/ProfileManager.test.tsx

@@ -883,6 +883,12 @@ describe('ProfileManager', () => {
       });
     });
 
+    it('should not render auth views when the user is already authenticated', () => {
+      render(<ProfileManager {...defaultAuthenticatedProps} />);
+      expect(screen.queryByText('Sign In')).not.toBeInTheDocument();
+      expect(screen.queryByText('Create an Account')).not.toBeInTheDocument();
+    });
+
     it('should log warning if address fetch returns null', async () => {
       console.log('[TEST DEBUG] Running: should log warning if address fetch returns null');
       const loggerSpy = vi.spyOn(logger.logger, 'warn');
@@ -905,5 +911,106 @@ describe('ProfileManager', () => {
         );
       });
     });
+
+    it('should handle updating the user profile and address with empty strings', async () => {
+      mockedApiClient.updateUserProfile.mockImplementation(async (data) =>
+        new Response(JSON.stringify({ ...authenticatedProfile, ...data })),
+      );
+      mockedApiClient.updateUserAddress.mockImplementation(async (data) =>
+        new Response(JSON.stringify({ ...mockAddress, ...data })),
+      );
+
+      render(<ProfileManager {...defaultAuthenticatedProps} />);
+
+      await waitFor(() => {
+        expect(screen.getByLabelText(/full name/i)).toHaveValue(authenticatedProfile.full_name);
+      });
+      await waitFor(() => expect(screen.getByLabelText(/city/i)).toHaveValue(mockAddress.city));
+
+      fireEvent.change(screen.getByLabelText(/full name/i), { target: { value: '' } });
+      fireEvent.change(screen.getByLabelText(/city/i), { target: { value: '' } });
+
+      const saveButton = screen.getByRole('button', { name: /save profile/i });
+      fireEvent.click(saveButton);
+
+      await waitFor(() => {
+        expect(mockedApiClient.updateUserProfile).toHaveBeenCalledWith(
+          { full_name: '', avatar_url: authenticatedProfile.avatar_url },
+          expect.objectContaining({ signal: expect.anything() }),
+        );
+        expect(mockedApiClient.updateUserAddress).toHaveBeenCalledWith(
+          expect.objectContaining({ city: '' }),
+          expect.objectContaining({ signal: expect.anything() }),
+        );
+        expect(mockOnProfileUpdate).toHaveBeenCalledWith(
+          expect.objectContaining({ full_name: '' })
+        );
+        expect(notifySuccess).toHaveBeenCalledWith('Profile updated successfully!');
+      });
+    });
+
+    it('should correctly clear the form when userProfile.address_id is null', async () => {
+      const profileNoAddress = { ...authenticatedProfile, address_id: null };
+      render(
+        <ProfileManager
+          {...defaultAuthenticatedProps}
+          userProfile={profileNoAddress as any} // Forcefully override the type to simulate address_id: null
+        />,
+      );
+
+      await waitFor(() => {
+        expect(screen.getByLabelText(/address line 1/i)).toHaveValue('');
+        expect(screen.getByLabelText(/city/i)).toHaveValue('');
+        expect(screen.getByLabelText(/province \/ state/i)).toHaveValue('');
+        expect(screen.getByLabelText(/postal \/ zip code/i)).toHaveValue('');
+        expect(screen.getByLabelText(/country/i)).toHaveValue('');
+      });
+    });
+
+    it('should show error notification when manual geocoding fails', async () => {
+      render(<ProfileManager {...defaultAuthenticatedProps} />);
+      await waitFor(() => expect(screen.getByLabelText(/city/i)).toHaveValue(mockAddress.city));
+
+      (mockedApiClient.geocodeAddress as Mock).mockRejectedValue(new Error('Geocoding failed'));
+
+      fireEvent.click(screen.getByRole('button', { name: /re-geocode/i }));
+
+      await waitFor(() => {
+        expect(notifyError).toHaveBeenCalledWith('Geocoding failed');
+      });
+    });
+
+    it('should show error notification when auto-geocoding fails', async () => {
+      vi.useFakeTimers();
+      render(<ProfileManager {...defaultAuthenticatedProps} />);
+
+      // Wait for initial load
+      await act(async () => {
+        await vi.runAllTimersAsync();
+      });
+
+      (mockedApiClient.geocodeAddress as Mock).mockRejectedValue(new Error('Auto-geocode error'));
+
+      fireEvent.change(screen.getByLabelText(/city/i), { target: { value: 'ErrorCity' } });
+
+      await act(async () => {
+        await vi.runAllTimersAsync();
+      });
+
+      expect(notifyError).toHaveBeenCalledWith('Auto-geocode error');
+    });
+
+    it('should handle permission denied error during geocoding', async () => {
+      render(<ProfileManager {...defaultAuthenticatedProps} />);
+      await waitFor(() => expect(screen.getByLabelText(/city/i)).toHaveValue(mockAddress.city));
+
+      (mockedApiClient.geocodeAddress as Mock).mockRejectedValue(new Error('Permission denied'));
+
+      fireEvent.click(screen.getByRole('button', { name: /re-geocode/i }));
+
+      await waitFor(() => {
+        expect(notifyError).toHaveBeenCalledWith('Permission denied');
+      });
+    });
   });
 });

src/pages/admin/components/StatCard.test.tsx

@@ -1,18 +1,19 @@
 import React from 'react';
-import { render, screen } from '@testing-library/react';
+import { screen } from '@testing-library/react';
 import { describe, it, expect } from 'vitest';
 import { StatCard } from './StatCard';
+import { renderWithProviders } from '../../../tests/utils/renderWithProviders';
 
 describe('StatCard', () => {
   it('should render the title and value correctly', () => {
-    render(<StatCard title="Test Stat" value="1,234" icon={<div data-testid="icon" />} />);
+    renderWithProviders(<StatCard title="Test Stat" value="1,234" icon={<div data-testid="icon" />} />);
 
     expect(screen.getByText('Test Stat')).toBeInTheDocument();
     expect(screen.getByText('1,234')).toBeInTheDocument();
   });
 
   it('should render the icon', () => {
-    render(
+    renderWithProviders(
       <StatCard title="Test Stat" value={100} icon={<div data-testid="test-icon">Icon</div>} />,
     );
 

src/pages/admin/components/SystemCheck.test.tsx

@@ -1,15 +1,22 @@
 // src/pages/admin/components/SystemCheck.test.tsx
 import React from 'react';
-import { render, screen, waitFor, cleanup, fireEvent, act } from '@testing-library/react';
+import { screen, waitFor, cleanup, fireEvent, act } from '@testing-library/react';
 import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
 import { SystemCheck } from './SystemCheck';
 import * as apiClient from '../../../services/apiClient';
 import toast from 'react-hot-toast';
 import { createMockUser } from '../../../tests/utils/mockFactories';
+import { renderWithProviders } from '../../../tests/utils/renderWithProviders';
 
 // Mock the entire apiClient module to ensure all exports are defined.
 // This is the primary fix for the error: [vitest] No "..." export is defined on the mock.
 vi.mock('../../../services/apiClient', () => ({
+  // Mocks for providers used by renderWithProviders
+  fetchFlyers: vi.fn(),
+  fetchMasterItems: vi.fn(),
+  fetchWatchedItems: vi.fn(),
+  fetchShoppingLists: vi.fn(),
+  getAuthenticatedUserProfile: vi.fn(),
   pingBackend: vi.fn(),
   checkStorage: vi.fn(),
   checkDbPoolHealth: vi.fn(),
@@ -20,7 +27,6 @@ vi.mock('../../../services/apiClient', () => ({
   triggerFailingJob: vi.fn(),
   clearGeocodeCache: vi.fn(),
 }));
-
 // Get a type-safe mocked version of the apiClient module.
 const mockedApiClient = vi.mocked(apiClient);
 
@@ -100,7 +106,7 @@ describe('SystemCheck', () => {
 
   it('should render initial idle state and then run checks automatically on mount', async () => {
     setGeminiApiKey('mock-api-key');
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     // Initially, all checks should be in 'running' state due to auto-run
     // However, the API key check is synchronous and resolves immediately.
@@ -126,7 +132,7 @@ describe('SystemCheck', () => {
 
   it('should show API key as failed if GEMINI_API_KEY is not set', async () => {
     setGeminiApiKey(undefined);
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     // Wait for the specific error message to appear.
     expect(
@@ -139,7 +145,7 @@ describe('SystemCheck', () => {
   it('should show backend connection as failed if pingBackend fails', async () => {
     setGeminiApiKey('mock-api-key');
     (mockedApiClient.pingBackend as Mock).mockRejectedValueOnce(new Error('Network error'));
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       expect(screen.getByText('Network error')).toBeInTheDocument();
@@ -164,7 +170,7 @@ describe('SystemCheck', () => {
         new Response(JSON.stringify({ success: false, message: 'PM2 process not found' })),
       ),
     );
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       expect(screen.getByText('PM2 process not found')).toBeInTheDocument();
@@ -174,7 +180,7 @@ describe('SystemCheck', () => {
   it('should show database pool check as failed if checkDbPoolHealth fails', async () => {
     setGeminiApiKey('mock-api-key'); // This was missing
     mockedApiClient.checkDbPoolHealth.mockRejectedValueOnce(new Error('DB connection refused'));
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       expect(screen.getByText('DB connection refused')).toBeInTheDocument();
@@ -184,7 +190,7 @@ describe('SystemCheck', () => {
   it('should show Redis check as failed if checkRedisHealth fails', async () => {
     setGeminiApiKey('mock-api-key');
     mockedApiClient.checkRedisHealth.mockRejectedValueOnce(new Error('Redis connection refused'));
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       expect(screen.getByText('Redis connection refused')).toBeInTheDocument();
@@ -197,7 +203,7 @@ describe('SystemCheck', () => {
     mockedApiClient.checkDbPoolHealth.mockImplementationOnce(() =>
       Promise.reject(new Error('DB connection refused')),
     );
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       // Verify the specific "skipped" messages for DB-dependent checks
@@ -214,7 +220,7 @@ describe('SystemCheck', () => {
     mockedApiClient.checkDbSchema.mockImplementationOnce(() =>
       Promise.resolve(new Response(JSON.stringify({ success: false, message: 'Schema mismatch' }))),
     );
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       expect(screen.getByText('Schema mismatch')).toBeInTheDocument();
@@ -224,7 +230,7 @@ describe('SystemCheck', () => {
   it('should show seeded user check as failed if loginUser fails', async () => {
     setGeminiApiKey('mock-api-key');
     mockedApiClient.loginUser.mockRejectedValueOnce(new Error('Incorrect email or password'));
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       expect(
@@ -236,7 +242,7 @@ describe('SystemCheck', () => {
   it('should show a generic failure message for other login errors', async () => {
     setGeminiApiKey('mock-api-key');
     mockedApiClient.loginUser.mockRejectedValueOnce(new Error('Server is on fire'));
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       expect(screen.getByText('Failed: Server is on fire')).toBeInTheDocument();
@@ -246,7 +252,7 @@ describe('SystemCheck', () => {
   it('should show storage directory check as failed if checkStorage fails', async () => {
     setGeminiApiKey('mock-api-key');
     mockedApiClient.checkStorage.mockRejectedValueOnce(new Error('Storage not writable'));
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       expect(screen.getByText('Storage not writable')).toBeInTheDocument();
@@ -262,7 +268,7 @@ describe('SystemCheck', () => {
     });
     mockedApiClient.pingBackend.mockImplementation(() => mockPromise);
 
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     // The button text changes to "Running Checks..."
     const runningButton = screen.getByRole('button', { name: /running checks/i });
@@ -283,7 +289,7 @@ describe('SystemCheck', () => {
 
   it('should re-run checks when the "Re-run Checks" button is clicked', async () => {
     setGeminiApiKey('mock-api-key');
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     // Wait for initial auto-run to complete
     await waitFor(() => expect(screen.getByText(/finished in/i)).toBeInTheDocument());
@@ -328,7 +334,7 @@ describe('SystemCheck', () => {
     mockedApiClient.checkDbSchema.mockImplementationOnce(() =>
       Promise.resolve(new Response(JSON.stringify({ success: false, message: 'Schema mismatch' }))),
     );
-    const { container } = render(<SystemCheck />);
+    const { container } = renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       // Instead of test-ids, we check for the result: the icon's color class.
@@ -344,7 +350,7 @@ describe('SystemCheck', () => {
 
   it('should display elapsed time after checks complete', async () => {
     setGeminiApiKey('mock-api-key');
-    render(<SystemCheck />);
+    renderWithProviders(<SystemCheck />);
 
     await waitFor(() => {
       const elapsedTimeText = screen.getByText(/finished in \d+\.\d{2} seconds\./i);
@@ -357,7 +363,7 @@ describe('SystemCheck', () => {
 
   describe('Integration: Job Queue Retries', () => {
     it('should call triggerFailingJob and show a success toast', async () => {
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
       const triggerButton = screen.getByRole('button', { name: /trigger failing job/i });
       fireEvent.click(triggerButton);
 
@@ -374,7 +380,7 @@ describe('SystemCheck', () => {
       });
       mockedApiClient.triggerFailingJob.mockImplementation(() => mockPromise);
 
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
       const triggerButton = screen.getByRole('button', { name: /trigger failing job/i });
       fireEvent.click(triggerButton);
 
@@ -390,7 +396,7 @@ describe('SystemCheck', () => {
 
     it('should show an error toast if triggering the job fails', async () => {
       mockedApiClient.triggerFailingJob.mockRejectedValueOnce(new Error('Queue is down'));
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
       const triggerButton = screen.getByRole('button', { name: /trigger failing job/i });
       fireEvent.click(triggerButton);
 
@@ -403,7 +409,7 @@ describe('SystemCheck', () => {
       mockedApiClient.triggerFailingJob.mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'Server error' }), { status: 500 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
       const triggerButton = screen.getByRole('button', { name: /trigger failing job/i });
       fireEvent.click(triggerButton);
 
@@ -420,7 +426,7 @@ describe('SystemCheck', () => {
     });
 
     it('should call clearGeocodeCache and show a success toast', async () => {
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
       // Wait for checks to run and Redis to be OK
       await waitFor(() => expect(screen.getByText('Redis OK')).toBeInTheDocument());
 
@@ -435,7 +441,7 @@ describe('SystemCheck', () => {
 
     it('should show an error toast if clearing the cache fails', async () => {
       mockedApiClient.clearGeocodeCache.mockRejectedValueOnce(new Error('Redis is busy'));
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
       await waitFor(() => expect(screen.getByText('Redis OK')).toBeInTheDocument());
       fireEvent.click(screen.getByRole('button', { name: /clear geocode cache/i }));
       await waitFor(() => expect(vi.mocked(toast).error).toHaveBeenCalledWith('Redis is busy'));
@@ -443,7 +449,7 @@ describe('SystemCheck', () => {
 
     it('should not call clearGeocodeCache if user cancels confirmation', async () => {
       vi.spyOn(window, 'confirm').mockReturnValue(false);
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
       await waitFor(() => expect(screen.getByText('Redis OK')).toBeInTheDocument());
 
       const clearButton = screen.getByRole('button', { name: /clear geocode cache/i });
@@ -456,7 +462,7 @@ describe('SystemCheck', () => {
       mockedApiClient.clearGeocodeCache.mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'Cache clear failed' }), { status: 500 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
       await waitFor(() => expect(screen.getByText('Redis OK')).toBeInTheDocument());
 
       fireEvent.click(screen.getByRole('button', { name: /clear geocode cache/i }));
@@ -470,7 +476,7 @@ describe('SystemCheck', () => {
       mockedApiClient.checkRedisHealth.mockResolvedValueOnce(
         new Response(JSON.stringify({ success: false, message: 'Redis down' })),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => expect(screen.getByText('Redis down')).toBeInTheDocument());
 
@@ -486,7 +492,7 @@ describe('SystemCheck', () => {
       mockedApiClient.pingBackend.mockResolvedValueOnce(
         new Response('unexpected response', { status: 200 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => {
         expect(
@@ -499,7 +505,7 @@ describe('SystemCheck', () => {
       mockedApiClient.checkStorage.mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'Permission denied' }), { status: 403 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => {
         expect(screen.getByText('Permission denied')).toBeInTheDocument();
@@ -511,7 +517,7 @@ describe('SystemCheck', () => {
       mockedApiClient.checkDbSchema.mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'Schema check failed 500' }), { status: 500 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => {
         expect(screen.getByText('Schema check failed 500')).toBeInTheDocument();
@@ -523,7 +529,7 @@ describe('SystemCheck', () => {
       mockedApiClient.checkDbPoolHealth.mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'DB Pool check failed 500' }), { status: 500 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => {
         expect(screen.getByText('DB Pool check failed 500')).toBeInTheDocument();
@@ -535,7 +541,7 @@ describe('SystemCheck', () => {
       mockedApiClient.checkPm2Status.mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'PM2 check failed 500' }), { status: 500 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => {
         expect(screen.getByText('PM2 check failed 500')).toBeInTheDocument();
@@ -547,7 +553,7 @@ describe('SystemCheck', () => {
       mockedApiClient.checkRedisHealth.mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'Redis check failed 500' }), { status: 500 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => {
         expect(screen.getByText('Redis check failed 500')).toBeInTheDocument();
@@ -559,7 +565,7 @@ describe('SystemCheck', () => {
       mockedApiClient.checkRedisHealth.mockResolvedValueOnce(
         new Response(JSON.stringify({ success: false, message: 'Redis is down' })),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => {
         expect(screen.getByText('Redis is down')).toBeInTheDocument();
@@ -571,7 +577,7 @@ describe('SystemCheck', () => {
       mockedApiClient.loginUser.mockResolvedValueOnce(
         new Response(JSON.stringify({ message: 'Invalid credentials' }), { status: 401 }),
       );
-      render(<SystemCheck />);
+      renderWithProviders(<SystemCheck />);
 
       await waitFor(() => {
         expect(screen.getByText('Failed: Invalid credentials')).toBeInTheDocument();

src/providers/AppProviders.test.tsx

@@ -0,0 +1,72 @@
+// src/providers/AppProviders.test.tsx
+import React from 'react';
+import { render, screen } from '@testing-library/react';
+import { describe, it, expect, vi } from 'vitest';
+import { AppProviders } from './AppProviders';
+
+// Mock all the providers to avoid their side effects and isolate AppProviders logic.
+// We render a simple div with a data-testid for each to verify nesting.
+vi.mock('./ModalProvider', () => ({
+  ModalProvider: ({ children }: { children: React.ReactNode }) => (
+    <div data-testid="modal-provider">{children}</div>
+  ),
+}));
+
+vi.mock('./AuthProvider', () => ({
+  AuthProvider: ({ children }: { children: React.ReactNode }) => (
+    <div data-testid="auth-provider">{children}</div>
+  ),
+}));
+
+vi.mock('./FlyersProvider', () => ({
+  FlyersProvider: ({ children }: { children: React.ReactNode }) => (
+    <div data-testid="flyers-provider">{children}</div>
+  ),
+}));
+
+vi.mock('./MasterItemsProvider', () => ({
+  MasterItemsProvider: ({ children }: { children: React.ReactNode }) => (
+    <div data-testid="master-items-provider">{children}</div>
+  ),
+}));
+
+vi.mock('./UserDataProvider', () => ({
+  UserDataProvider: ({ children }: { children: React.ReactNode }) => (
+    <div data-testid="user-data-provider">{children}</div>
+  ),
+}));
+
+describe('AppProviders', () => {
+  it('renders children correctly', () => {
+    render(
+      <AppProviders>
+        <div data-testid="test-child">Test Child</div>
+      </AppProviders>,
+    );
+
+    expect(screen.getByTestId('test-child')).toBeInTheDocument();
+    expect(screen.getByText('Test Child')).toBeInTheDocument();
+  });
+
+  it('renders providers in the correct nesting order', () => {
+    render(
+      <AppProviders>
+        <div data-testid="test-child">Test Child</div>
+      </AppProviders>,
+    );
+
+    const modalProvider = screen.getByTestId('modal-provider');
+    const authProvider = screen.getByTestId('auth-provider');
+    const flyersProvider = screen.getByTestId('flyers-provider');
+    const masterItemsProvider = screen.getByTestId('master-items-provider');
+    const userDataProvider = screen.getByTestId('user-data-provider');
+    const child = screen.getByTestId('test-child');
+
+    // Verify nesting structure: Modal -> Auth -> Flyers -> MasterItems -> UserData -> Child
+    expect(modalProvider).toContainElement(authProvider);
+    expect(authProvider).toContainElement(flyersProvider);
+    expect(flyersProvider).toContainElement(masterItemsProvider);
+    expect(masterItemsProvider).toContainElement(userDataProvider);
+    expect(userDataProvider).toContainElement(child);
+  });
+});

src/providers/AuthProvider.test.tsx

@@ -0,0 +1,245 @@
+// src/providers/AuthProvider.test.tsx
+import React, { useContext, useState } from 'react';
+import { render, screen, waitFor, fireEvent, act } from '@testing-library/react';
+import { describe, it, expect, vi, beforeEach, type Mocked } from 'vitest';
+import { AuthProvider } from './AuthProvider';
+import { AuthContext } from '../contexts/AuthContext';
+import * as apiClient from '../services/apiClient';
+import * as tokenStorage from '../services/tokenStorage';
+import { createMockUserProfile } from '../tests/utils/mockFactories';
+
+// Mocks
+vi.mock('../services/apiClient');
+vi.mock('../services/tokenStorage');
+vi.mock('../services/logger.client', () => ({
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+const mockedApiClient = apiClient as Mocked<typeof apiClient>;
+const mockedTokenStorage = tokenStorage as Mocked<typeof tokenStorage>;
+
+const mockProfile = createMockUserProfile({
+  user: { user_id: 'user-123', email: 'test@example.com' },
+});
+
+// A simple consumer component to access and display context values
+const TestConsumer = () => {
+  const context = useContext(AuthContext);
+  const [error, setError] = useState<string | null>(null);
+  if (!context) {
+    return <div>No Context</div>;
+  }
+
+  const handleLoginWithoutProfile = async () => {
+    try {
+      await context.login('test-token-no-profile');
+    } catch (e) {
+      setError(e instanceof Error ? e.message : String(e));
+    }
+  };
+
+  return (
+    <div>
+      <div data-testid="auth-status">{context.authStatus}</div>
+      <div data-testid="user-email">{context.userProfile?.user.email ?? 'No User'}</div>
+      <div data-testid="is-loading">{context.isLoading.toString()}</div>
+      {error && <div data-testid="error-display">{error}</div>}
+      <button onClick={() => context.login('test-token', mockProfile)}>Login with Profile</button>
+      <button onClick={handleLoginWithoutProfile}>Login without Profile</button>
+      <button onClick={context.logout}>Logout</button>
+      <button onClick={() => context.updateProfile({ full_name: 'Updated Name' })}>
+        Update Profile
+      </button>
+    </div>
+  );
+};
+
+const renderWithProvider = () => {
+  return render(
+    <AuthProvider>
+      <TestConsumer />
+    </AuthProvider>,
+  );
+};
+
+describe('AuthProvider', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should start in "Determining..." state and transition to "SIGNED_OUT" if no token exists', async () => {
+    mockedTokenStorage.getToken.mockReturnValue(null);
+    renderWithProvider();
+
+    // The transition happens synchronously in the effect when no token is present,
+    // so 'Determining...' might be skipped or flashed too quickly for the test runner.
+    // We check that it settles correctly.
+
+    await waitFor(() => {
+      expect(screen.getByTestId('auth-status')).toHaveTextContent('SIGNED_OUT');
+      expect(screen.getByTestId('is-loading')).toHaveTextContent('false');
+    });
+
+    expect(mockedApiClient.getAuthenticatedUserProfile).not.toHaveBeenCalled();
+  });
+
+  it('should transition to "AUTHENTICATED" if a valid token exists', async () => {
+    mockedTokenStorage.getToken.mockReturnValue('valid-token');
+    mockedApiClient.getAuthenticatedUserProfile.mockResolvedValue(
+      new Response(JSON.stringify(mockProfile)),
+    );
+
+    renderWithProvider();
+
+    await waitFor(() => {
+      expect(screen.getByTestId('auth-status')).toHaveTextContent('AUTHENTICATED');
+      expect(screen.getByTestId('user-email')).toHaveTextContent('test@example.com');
+      expect(screen.getByTestId('is-loading')).toHaveTextContent('false');
+    });
+
+    expect(mockedApiClient.getAuthenticatedUserProfile).toHaveBeenCalledTimes(1);
+  });
+
+  it('should handle token validation failure by signing out', async () => {
+    mockedTokenStorage.getToken.mockReturnValue('invalid-token');
+    mockedApiClient.getAuthenticatedUserProfile.mockRejectedValue(new Error('Invalid Token'));
+
+    renderWithProvider();
+
+    await waitFor(() => {
+      expect(screen.getByTestId('auth-status')).toHaveTextContent('SIGNED_OUT');
+    });
+
+    expect(mockedTokenStorage.removeToken).toHaveBeenCalled();
+  });
+
+  it('should handle a valid token that returns no profile by signing out', async () => {
+    // This test covers lines 51-55
+    mockedTokenStorage.getToken.mockReturnValue('valid-token-no-profile');
+    mockedApiClient.getAuthenticatedUserProfile.mockResolvedValue(
+      new Response(JSON.stringify(null)),
+    );
+
+    renderWithProvider();
+
+    expect(screen.getByTestId('auth-status')).toHaveTextContent('Determining...');
+
+    await waitFor(() => {
+      expect(screen.getByTestId('auth-status')).toHaveTextContent('SIGNED_OUT');
+    });
+
+    expect(mockedTokenStorage.removeToken).toHaveBeenCalled();
+    expect(screen.getByTestId('user-email')).toHaveTextContent('No User');
+    expect(screen.getByTestId('is-loading')).toHaveTextContent('false');
+  });
+
+  it('should log in a user with provided profile data', async () => {
+    mockedTokenStorage.getToken.mockReturnValue(null);
+    renderWithProvider();
+    await waitFor(() => expect(screen.getByTestId('auth-status')).toHaveTextContent('SIGNED_OUT'));
+
+    const loginButton = screen.getByRole('button', { name: 'Login with Profile' });
+    await act(async () => {
+      fireEvent.click(loginButton);
+    });
+
+    expect(mockedTokenStorage.setToken).toHaveBeenCalledWith('test-token');
+    expect(screen.getByTestId('auth-status')).toHaveTextContent('AUTHENTICATED');
+    expect(screen.getByTestId('user-email')).toHaveTextContent('test@example.com');
+    // API should not be called if profile is provided
+    expect(mockedApiClient.getAuthenticatedUserProfile).not.toHaveBeenCalled();
+  });
+
+  it('should log in a user and fetch profile if not provided', async () => {
+    mockedTokenStorage.getToken.mockReturnValue(null);
+    mockedApiClient.getAuthenticatedUserProfile.mockResolvedValue(
+      new Response(JSON.stringify(mockProfile)),
+    );
+    renderWithProvider();
+    await waitFor(() => expect(screen.getByTestId('auth-status')).toHaveTextContent('SIGNED_OUT'));
+
+    const loginButton = screen.getByRole('button', { name: 'Login without Profile' });
+    await act(async () => {
+      fireEvent.click(loginButton);
+    });
+
+    await waitFor(() => {
+      expect(screen.getByTestId('auth-status')).toHaveTextContent('AUTHENTICATED');
+      expect(screen.getByTestId('user-email')).toHaveTextContent('test@example.com');
+    });
+
+    expect(mockedTokenStorage.setToken).toHaveBeenCalledWith('test-token-no-profile');
+    expect(mockedApiClient.getAuthenticatedUserProfile).toHaveBeenCalledTimes(1);
+  });
+
+  it('should throw an error and log out if profile fetch fails after login', async () => {
+    // This test covers lines 109-111
+    mockedTokenStorage.getToken.mockReturnValue(null);
+    const fetchError = new Error('API is down');
+    mockedApiClient.getAuthenticatedUserProfile.mockRejectedValue(fetchError);
+
+    renderWithProvider();
+
+    await waitFor(() => {
+      expect(screen.getByTestId('auth-status')).toHaveTextContent('SIGNED_OUT');
+    });
+
+    const loginButton = screen.getByRole('button', { name: 'Login without Profile' });
+
+    // Click the button that triggers the failing login
+    fireEvent.click(loginButton);
+
+    // After the error is thrown, the state should be rolled back
+    await waitFor(() => {
+      // The error is now caught and displayed by the TestConsumer
+      expect(screen.getByTestId('error-display')).toHaveTextContent(
+        'Login succeeded, but failed to fetch your data: API is down',
+      );
+
+      expect(mockedTokenStorage.setToken).toHaveBeenCalledWith('test-token-no-profile');
+      expect(mockedTokenStorage.removeToken).toHaveBeenCalled();
+      expect(screen.getByTestId('auth-status')).toHaveTextContent('SIGNED_OUT');
+    });
+  });
+
+  it('should log out the user', async () => {
+    mockedTokenStorage.getToken.mockReturnValue('valid-token');
+    mockedApiClient.getAuthenticatedUserProfile.mockResolvedValue(
+      new Response(JSON.stringify(mockProfile)),
+    );
+    renderWithProvider();
+    await waitFor(() => expect(screen.getByTestId('auth-status')).toHaveTextContent('AUTHENTICATED'));
+
+    const logoutButton = screen.getByRole('button', { name: 'Logout' });
+    fireEvent.click(logoutButton);
+
+    expect(screen.getByTestId('auth-status')).toHaveTextContent('SIGNED_OUT');
+    expect(screen.getByTestId('user-email')).toHaveTextContent('No User');
+    expect(mockedTokenStorage.removeToken).toHaveBeenCalled();
+  });
+
+  it('should update the user profile', async () => {
+    mockedTokenStorage.getToken.mockReturnValue('valid-token');
+    mockedApiClient.getAuthenticatedUserProfile.mockResolvedValue(
+      new Response(JSON.stringify(mockProfile)),
+    );
+    renderWithProvider();
+    await waitFor(() => expect(screen.getByTestId('auth-status')).toHaveTextContent('AUTHENTICATED'));
+
+    const updateButton = screen.getByRole('button', { name: 'Update Profile' });
+    fireEvent.click(updateButton);
+
+    await waitFor(() => {
+      // The profile object is internal, so we can't directly check it.
+      // A good proxy is to see if a component that uses it would re-render.
+      // Since our consumer doesn't display the name, we just confirm the function was called.
+      // In a real app, we'd check the updated UI element.
+      expect(screen.getByTestId('auth-status')).toHaveTextContent('AUTHENTICATED');
+    });
+  });
+});

src/routes/passport.routes.test.ts

@@ -482,8 +482,8 @@ describe('Passport Configuration', () => {
       const mockReq: Partial<Request> = {
         // An object that is not a valid UserProfile (e.g., missing 'role')
         user: {
-          user_id: 'invalid-user-id',
-        } as any,
+          user: { user_id: 'invalid-user-id' }, // Missing 'role' property
+        } as unknown as UserProfile, // Cast to UserProfile to satisfy req.user type, but it's intentionally malformed
       };
 
       // Act

src/routes/recipe.routes.ts

@@ -2,6 +2,8 @@
 import { Router } from 'express';
 import { z } from 'zod';
 import * as db from '../services/db/index.db';
+import { aiService } from '../services/aiService.server';
+import passport from './passport.routes';
 import { validateRequest } from '../middleware/validation.middleware';
 import { requiredString, numericIdParam, optionalNumeric } from '../utils/zodUtils';
 
@@ -28,6 +30,12 @@ const byIngredientAndTagSchema = z.object({
 
 const recipeIdParamsSchema = numericIdParam('recipeId');
 
+const suggestRecipeSchema = z.object({
+  body: z.object({
+    ingredients: z.array(z.string().min(1)).nonempty('At least one ingredient is required.'),
+  }),
+});
+
 /**
  * GET /api/recipes/by-sale-percentage - Get recipes based on the percentage of their ingredients on sale.
  */
@@ -121,4 +129,31 @@ router.get('/:recipeId', validateRequest(recipeIdParamsSchema), async (req, res,
   }
 });
 
+/**
+ * POST /api/recipes/suggest - Generates a simple recipe suggestion from a list of ingredients.
+ * This is a protected endpoint.
+ */
+router.post(
+  '/suggest',
+  passport.authenticate('jwt', { session: false }),
+  validateRequest(suggestRecipeSchema),
+  async (req, res, next) => {
+    try {
+      const { body } = req as unknown as z.infer<typeof suggestRecipeSchema>;
+      const suggestion = await aiService.generateRecipeSuggestion(body.ingredients, req.log);
+
+      if (!suggestion) {
+        return res
+          .status(503)
+          .json({ message: 'AI service is currently unavailable or failed to generate a suggestion.' });
+      }
+
+      res.json({ suggestion });
+    } catch (error) {
+      req.log.error({ error }, 'Error generating recipe suggestion');
+      next(error);
+    }
+  },
+);
+
 export default router;

src/routes/user.routes.test.ts

@@ -482,6 +482,12 @@ describe('User Routes (/api/users)', () => {
 
         expect(response.status).toBe(201);
         expect(response.body).toEqual(mockAddedItem);
+        expect(db.shoppingRepo.addShoppingListItem).toHaveBeenCalledWith(
+          listId,
+          mockUserProfile.user.user_id,
+          itemData,
+          expectLogger,
+        );
       });
 
       it('should return 400 on foreign key error when adding an item', async () => {
@@ -519,6 +525,12 @@ describe('User Routes (/api/users)', () => {
 
         expect(response.status).toBe(200);
         expect(response.body).toEqual(mockUpdatedItem);
+        expect(db.shoppingRepo.updateShoppingListItem).toHaveBeenCalledWith(
+          itemId,
+          mockUserProfile.user.user_id,
+          updates,
+          expectLogger,
+        );
       });
 
       it('should return 404 if item to update is not found', async () => {
@@ -554,6 +566,11 @@ describe('User Routes (/api/users)', () => {
           vi.mocked(db.shoppingRepo.removeShoppingListItem).mockResolvedValue(undefined);
           const response = await supertest(app).delete('/api/users/shopping-lists/items/101');
           expect(response.status).toBe(204);
+          expect(db.shoppingRepo.removeShoppingListItem).toHaveBeenCalledWith(
+            101,
+            mockUserProfile.user.user_id,
+            expectLogger,
+          );
         });
 
         it('should return 404 if item to delete is not found', async () => {

src/routes/user.routes.ts

@@ -478,10 +478,16 @@ router.post(
   validateRequest(addShoppingListItemSchema),
   async (req, res, next: NextFunction) => {
     logger.debug(`[ROUTE] POST /api/users/shopping-lists/:listId/items - ENTER`);
+    const userProfile = req.user as UserProfile;
     // Apply ADR-003 pattern for type safety
     const { params, body } = req as unknown as AddShoppingListItemRequest;
     try {
-      const newItem = await db.shoppingRepo.addShoppingListItem(params.listId, body, req.log);
+      const newItem = await db.shoppingRepo.addShoppingListItem(
+        params.listId,
+        userProfile.user.user_id,
+        body,
+        req.log,
+      );
       res.status(201).json(newItem);
     } catch (error) {
       if (error instanceof ForeignKeyConstraintError) {
@@ -512,11 +518,13 @@ router.put(
   validateRequest(updateShoppingListItemSchema),
   async (req, res, next: NextFunction) => {
     logger.debug(`[ROUTE] PUT /api/users/shopping-lists/items/:itemId - ENTER`);
+    const userProfile = req.user as UserProfile;
     // Apply ADR-003 pattern for type safety
     const { params, body } = req as unknown as UpdateShoppingListItemRequest;
     try {
       const updatedItem = await db.shoppingRepo.updateShoppingListItem(
         params.itemId,
+        userProfile.user.user_id,
         body,
         req.log,
       );
@@ -541,10 +549,11 @@ router.delete(
   validateRequest(shoppingListItemIdSchema),
   async (req, res, next: NextFunction) => {
     logger.debug(`[ROUTE] DELETE /api/users/shopping-lists/items/:itemId - ENTER`);
+    const userProfile = req.user as UserProfile;
     // Apply ADR-003 pattern for type safety
     const { params } = req as unknown as DeleteShoppingListItemRequest;
     try {
-      await db.shoppingRepo.removeShoppingListItem(params.itemId, req.log);
+      await db.shoppingRepo.removeShoppingListItem(params.itemId, userProfile.user.user_id, req.log);
       res.status(204).send();
     } catch (error: unknown) {
       logger.error(

src/services/aiService.server.test.ts

@@ -1,5 +1,6 @@
 // src/services/aiService.server.test.ts
 import { describe, it, expect, vi, beforeEach, afterEach, type Mock } from 'vitest';
+import type { Job } from 'bullmq';
 import { createMockLogger } from '../tests/utils/mockLogger';
 import type { Logger } from 'pino';
 import type { FlyerStatus, MasterGroceryItem, UserProfile } from '../types';
@@ -10,7 +11,7 @@ import {
   DuplicateFlyerError,
   type RawFlyerItem,
 } from './aiService.server';
-import { createMockMasterGroceryItem } from '../tests/utils/mockFactories';
+import { createMockMasterGroceryItem, createMockFlyer } from '../tests/utils/mockFactories';
 import { ValidationError } from './db/errors.db';
 import { AiFlyerDataSchema } from '../types/ai';
 
@@ -113,6 +114,7 @@ describe('AI Service (Server)', () => {
     // Restore all environment variables and clear all mocks before each test
     vi.restoreAllMocks();
     vi.clearAllMocks();
+    mockGenerateContent.mockReset();
     // Reset modules to ensure the service re-initializes with the mocks
 
     mockAiClient.generateContent.mockResolvedValue({
@@ -241,6 +243,7 @@ describe('AI Service (Server)', () => {
       vi.unstubAllEnvs();
       process.env = { ...originalEnv, GEMINI_API_KEY: 'test-key' };
       vi.resetModules(); // Re-import to use the new env var and re-instantiate the service
+      mockGenerateContent.mockReset();
     });
 
     afterEach(() => {
@@ -319,41 +322,174 @@ describe('AI Service (Server)', () => {
       const { logger } = await import('./logger.server');
       const serviceWithFallback = new AIService(logger);
 
-      const quotaError1 = new Error('Quota exhausted for model 1');
-      const quotaError2 = new Error('429 Too Many Requests for model 2');
-      const quotaError3 = new Error('RESOURCE_EXHAUSTED for model 3');
+      // Access private property for testing purposes to ensure test stays in sync with implementation
+      const models = (serviceWithFallback as any).models as string[];
+      // Use a quota error to trigger the fallback logic for each model
+      const errors = models.map((model, i) => new Error(`Quota error for model ${model} (${i})`));
+      const lastError = errors[errors.length - 1];
 
-      mockGenerateContent
-        .mockRejectedValueOnce(quotaError1)
-        .mockRejectedValueOnce(quotaError2)
-        .mockRejectedValueOnce(quotaError3);
+      // Dynamically setup mocks
+      errors.forEach((err) => {
+        mockGenerateContent.mockRejectedValueOnce(err);
+      });
 
       const request = { contents: [{ parts: [{ text: 'test prompt' }] }] };
 
       // Act & Assert
       await expect((serviceWithFallback as any).aiClient.generateContent(request)).rejects.toThrow(
-        quotaError3,
+        lastError,
       );
 
-      expect(mockGenerateContent).toHaveBeenCalledTimes(3);
-      expect(mockGenerateContent).toHaveBeenNthCalledWith(1, { // The first model in the list is now 'gemini-3-flash-preview'
-        model: 'gemini-3-flash-preview',
-        ...request,
-      });
-      expect(mockGenerateContent).toHaveBeenNthCalledWith(2, { // The second model in the list is 'gemini-2.5-flash'
-        model: 'gemini-2.5-flash',
-        ...request,
-      });
-      expect(mockGenerateContent).toHaveBeenNthCalledWith(3, { // The third model in the list is 'gemini-2.5-flash-lite'
-        model: 'gemini-2.5-flash-lite',
-        ...request,
+      expect(mockGenerateContent).toHaveBeenCalledTimes(models.length);
+
+      models.forEach((model, index) => {
+        expect(mockGenerateContent).toHaveBeenNthCalledWith(index + 1, {
+          model: model,
+          ...request,
+        });
       });
 
       expect(logger.error).toHaveBeenCalledWith(
-        { lastError: quotaError3 },
+        { lastError },
         '[AIService Adapter] All AI models failed. Throwing last known error.',
       );
     });
+
+    it('should use lite models and throw the last error if all lite models fail', async () => {
+      // Arrange
+      const { AIService } = await import('./aiService.server');
+      const { logger } = await import('./logger.server');
+      // We instantiate with the real logger to test the production fallback logic
+      const serviceWithFallback = new AIService(logger);
+
+      // Access private property for testing purposes
+      const modelsLite = (serviceWithFallback as any).models_lite as string[];
+      // Use a quota error to trigger the fallback logic for each model
+      const errors = modelsLite.map((model, i) => new Error(`Quota error for lite model ${model} (${i})`));
+      const lastError = errors[errors.length - 1];
+
+      // Dynamically setup mocks
+      errors.forEach((err) => {
+        mockGenerateContent.mockRejectedValueOnce(err);
+      });
+
+      const request = {
+        contents: [{ parts: [{ text: 'test prompt' }] }],
+        useLiteModels: true, // This is the key to trigger the lite model list
+      };
+      // The adapter strips `useLiteModels` before calling the underlying client,
+      // so we prepare the expected request shape for our assertions.
+      const { useLiteModels, ...apiReq } = request;
+
+      // Act & Assert
+      // Expect the entire operation to reject with the error from the very last model attempt.
+      await expect((serviceWithFallback as any).aiClient.generateContent(request)).rejects.toThrow(
+        lastError,
+      );
+
+      // Verify that all lite models were attempted in the correct order.
+      expect(mockGenerateContent).toHaveBeenCalledTimes(modelsLite.length);
+
+      modelsLite.forEach((model, index) => {
+        expect(mockGenerateContent).toHaveBeenNthCalledWith(index + 1, {
+          model: model,
+          ...apiReq,
+        });
+      });
+    });
+
+    it('should dynamically try the next model if the first one fails and succeed if the second one works', async () => {
+      // Arrange
+      const { AIService } = await import('./aiService.server');
+      const { logger } = await import('./logger.server');
+      const serviceWithFallback = new AIService(logger);
+
+      // Access private property for testing purposes
+      const models = (serviceWithFallback as any).models as string[];
+      // Ensure we have enough models to test fallback
+      expect(models.length).toBeGreaterThanOrEqual(2);
+
+      const error1 = new Error('Quota exceeded for model 1');
+      const successResponse = { text: 'Success', candidates: [] };
+
+      mockGenerateContent
+        .mockRejectedValueOnce(error1)
+        .mockResolvedValueOnce(successResponse);
+
+      const request = { contents: [{ parts: [{ text: 'test prompt' }] }] };
+
+      // Act
+      const result = await (serviceWithFallback as any).aiClient.generateContent(request);
+
+      // Assert
+      expect(result).toEqual(successResponse);
+      expect(mockGenerateContent).toHaveBeenCalledTimes(2);
+
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(1, {
+        model: models[0],
+        ...request,
+      });
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(2, {
+        model: models[1],
+        ...request,
+      });
+
+      expect(logger.warn).toHaveBeenCalledWith(
+        expect.stringContaining(`Model '${models[0]}' failed`),
+      );
+    });
+
+    it('should retry on a 429 error and succeed on the next model', async () => {
+      // Arrange
+      const { AIService } = await import('./aiService.server');
+      const { logger } = await import('./logger.server');
+      const serviceWithFallback = new AIService(logger);
+      const models = (serviceWithFallback as any).models as string[];
+
+      const retriableError = new Error('429 Too Many Requests');
+      const successResponse = { text: 'Success from second model', candidates: [] };
+
+      mockGenerateContent
+        .mockRejectedValueOnce(retriableError)
+        .mockResolvedValueOnce(successResponse);
+
+      const request = { contents: [{ parts: [{ text: 'test prompt' }] }] };
+
+      // Act
+      const result = await (serviceWithFallback as any).aiClient.generateContent(request);
+
+      // Assert
+      expect(result).toEqual(successResponse);
+      expect(mockGenerateContent).toHaveBeenCalledTimes(2);
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(1, { model: models[0], ...request });
+      expect(mockGenerateContent).toHaveBeenNthCalledWith(2, { model: models[1], ...request });
+      expect(logger.warn).toHaveBeenCalledWith(expect.stringContaining(`Model '${models[0]}' failed due to quota/rate limit.`));
+    });
+
+    it('should fail immediately on a 400 Bad Request error without retrying', async () => {
+      // Arrange
+      const { AIService } = await import('./aiService.server');
+      const { logger } = await import('./logger.server');
+      const serviceWithFallback = new AIService(logger);
+      const models = (serviceWithFallback as any).models as string[];
+
+      const nonRetriableError = new Error('400 Bad Request: Invalid input');
+      mockGenerateContent.mockRejectedValueOnce(nonRetriableError);
+
+      const request = { contents: [{ parts: [{ text: 'test prompt' }] }] };
+
+      // Act & Assert
+      await expect((serviceWithFallback as any).aiClient.generateContent(request)).rejects.toThrow(nonRetriableError);
+
+      expect(mockGenerateContent).toHaveBeenCalledTimes(1);
+      expect(mockGenerateContent).toHaveBeenCalledWith({ model: models[0], ...request });
+      expect(logger.error).toHaveBeenCalledWith(
+        { error: nonRetriableError },
+        `[AIService Adapter] Model '${models[0]}' failed with a non-retriable error.`,
+      );
+      // Ensure it didn't log a warning about trying the next model
+      expect(logger.warn).not.toHaveBeenCalledWith(expect.stringContaining('Trying next model'));
+    });
   });
 
   describe('extractItemsFromReceiptImage', () => {
@@ -783,7 +919,7 @@ describe('AI Service (Server)', () => {
     } as UserProfile;
 
     it('should throw DuplicateFlyerError if flyer already exists', async () => {
-      vi.mocked(dbModule.flyerRepo.findFlyerByChecksum).mockResolvedValue({ flyer_id: 99 } as any);
+      vi.mocked(dbModule.flyerRepo.findFlyerByChecksum).mockResolvedValue({ flyer_id: 99, checksum: 'checksum123', file_name: 'test.pdf', image_url: '/flyer-images/test.pdf', icon_url: '/flyer-images/icons/test.webp', store_id: 1, status: 'processed', item_count: 0, created_at: new Date().toISOString(), updated_at: new Date().toISOString() });
 
       await expect(
         aiServiceInstance.enqueueFlyerProcessing(
@@ -798,7 +934,7 @@ describe('AI Service (Server)', () => {
 
     it('should enqueue job with user address if profile exists', async () => {
       vi.mocked(dbModule.flyerRepo.findFlyerByChecksum).mockResolvedValue(undefined);
-      vi.mocked(flyerQueue.add).mockResolvedValue({ id: 'job123' } as any);
+      vi.mocked(flyerQueue.add).mockResolvedValue({ id: 'job123' } as unknown as Job);
 
       const result = await aiServiceInstance.enqueueFlyerProcessing(
         mockFile,
@@ -821,7 +957,7 @@ describe('AI Service (Server)', () => {
 
     it('should enqueue job without address if profile is missing', async () => {
       vi.mocked(dbModule.flyerRepo.findFlyerByChecksum).mockResolvedValue(undefined);
-      vi.mocked(flyerQueue.add).mockResolvedValue({ id: 'job456' } as any);
+      vi.mocked(flyerQueue.add).mockResolvedValue({ id: 'job456' } as unknown as Job);
 
       await aiServiceInstance.enqueueFlyerProcessing(
         mockFile,
@@ -850,7 +986,7 @@ describe('AI Service (Server)', () => {
     const mockProfile = { user: { user_id: 'u1' } } as UserProfile;
 
     beforeEach(() => {
-      // Default success mocks
+      // Default success mocks. Use createMockFlyer for a more complete mock.
       vi.mocked(dbModule.flyerRepo.findFlyerByChecksum).mockResolvedValue(undefined);
       vi.mocked(generateFlyerIcon).mockResolvedValue('icon.jpg');
       vi.mocked(createFlyerAndItems).mockResolvedValue({
@@ -887,7 +1023,7 @@ describe('AI Service (Server)', () => {
     });
 
     it('should throw DuplicateFlyerError if checksum exists', async () => {
-      vi.mocked(dbModule.flyerRepo.findFlyerByChecksum).mockResolvedValue({ flyer_id: 55 } as any);
+      vi.mocked(dbModule.flyerRepo.findFlyerByChecksum).mockResolvedValue(createMockFlyer({ flyer_id: 55 }));
       const body = { checksum: 'dup-sum' };
 
       await expect(

src/services/aiService.server.ts

@@ -62,6 +62,7 @@ interface IAiClient {
   generateContent(request: {
     contents: Content[];
     tools?: Tool[];
+    useLiteModels?: boolean;
   }): Promise<GenerateContentResponse>;
 }
 
@@ -93,7 +94,8 @@ export class AIService {
   // The fallback list is ordered by preference (speed/cost vs. power).
   // We try the fastest models first, then the more powerful 'pro' model as a high-quality fallback,
   // and finally the 'lite' model as a last resort.
-  private readonly models = [ 'gemini-3-flash-preview', 'gemini-2.5-flash', 'gemini-2.5-flash-lite'];
+  private readonly models = [ 'gemini-3-flash-preview', 'gemini-2.5-flash', 'gemini-2.5-flash-lite', 'gemma-3-27b', 'gemma-3-12b'];
+  private readonly models_lite = ["gemma-3-4b", "gemma-3-2b", "gemma-3-1b"];
 
   constructor(logger: Logger, aiClient?: IAiClient, fs?: IFileSystem) {
     this.logger = logger;
@@ -156,7 +158,9 @@ export class AIService {
                 throw new Error('AIService.generateContent requires at least one content element.');
               }
 
-              return this._generateWithFallback(genAI, request);
+              const { useLiteModels, ...apiReq } = request;
+              const models = useLiteModels ? this.models_lite : this.models;
+              return this._generateWithFallback(genAI, apiReq, models);
             },
           }
         : {
@@ -194,10 +198,11 @@ export class AIService {
   private async _generateWithFallback(
     genAI: GoogleGenAI,
     request: { contents: Content[]; tools?: Tool[] },
+    models: string[] = this.models,
   ): Promise<GenerateContentResponse> {
     let lastError: Error | null = null;
 
-    for (const modelName of this.models) {
+    for (const modelName of models) {
       try {
         this.logger.info(
           `[AIService Adapter] Attempting to generate content with model: ${modelName}`,
@@ -668,6 +673,33 @@ export class AIService {
     }
   }
 
+  /**
+   * Generates a simple recipe suggestion based on a list of ingredients.
+   * Uses the 'lite' models for faster/cheaper generation.
+   * @param ingredients List of available ingredients.
+   * @param logger Logger instance.
+   * @returns The recipe suggestion text.
+   */
+  async generateRecipeSuggestion(
+    ingredients: string[],
+    logger: Logger = this.logger,
+  ): Promise<string | null> {
+    const prompt = `Suggest a simple recipe using these ingredients: ${ingredients.join(', ')}. Keep it brief.`;
+
+    try {
+      const result = await this.rateLimiter(() =>
+        this.aiClient.generateContent({
+          contents: [{ parts: [{ text: prompt }] }],
+          useLiteModels: true,
+        }),
+      );
+      return result.text || null;
+    } catch (error) {
+      logger.error({ err: error }, 'Failed to generate recipe suggestion');
+      return null;
+    }
+  }
+
   /**
    * SERVER-SIDE FUNCTION
    * Uses Google Maps grounding to find nearby stores and plan a shopping trip.

src/services/apiClient.test.ts

@@ -543,6 +543,13 @@ describe('API Client', () => {
       await apiClient.deleteRecipe(recipeId);
       expect(capturedUrl?.pathname).toBe(`/api/recipes/${recipeId}`);
     });
+
+    it('suggestRecipe should send a POST request with ingredients', async () => {
+      const ingredients = ['chicken', 'rice'];
+      await apiClient.suggestRecipe(ingredients);
+      expect(capturedUrl?.pathname).toBe('/api/recipes/suggest');
+      expect(capturedBody).toEqual({ ingredients });
+    });
   });
 
   describe('User Profile and Settings API Functions', () => {
@@ -933,7 +940,7 @@ describe('API Client', () => {
 
     it('logSearchQuery should send a POST request with query data', async () => {
       const queryData = createMockSearchQueryPayload({ query_text: 'apples', result_count: 10, was_successful: true });
-      await apiClient.logSearchQuery(queryData);
+      await apiClient.logSearchQuery(queryData as any);
       expect(capturedUrl?.pathname).toBe('/api/search/log');
       expect(capturedBody).toEqual(queryData);
     });
@@ -960,7 +967,7 @@ describe('API Client', () => {
         result_count: 0,
         was_successful: false,
       });
-      await apiClient.logSearchQuery(queryData);
+      await apiClient.logSearchQuery(queryData as any);
       expect(logger.warn).toHaveBeenCalledWith('Failed to log search query', { error: apiError });
     });
   });

src/services/apiClient.ts

@@ -636,6 +636,20 @@ export const addRecipeComment = (
 ): Promise<Response> =>
   authedPost(`/recipes/${recipeId}/comments`, { content, parentCommentId }, { tokenOverride });
 
+/**
+ * Requests a simple recipe suggestion from the AI based on a list of ingredients.
+ * @param ingredients An array of ingredient strings.
+ * @param tokenOverride Optional token for testing.
+ * @returns A promise that resolves to the API response containing the suggestion.
+ */
+export const suggestRecipe = (
+  ingredients: string[],
+  tokenOverride?: string,
+): Promise<Response> => {
+  // This is a protected endpoint, so we use authedPost.
+  return authedPost('/recipes/suggest', { ingredients }, { tokenOverride });
+};
+
 /**
  * Deletes a recipe.
  * @param recipeId The ID of the recipe to delete.

src/services/authService.test.ts

@@ -17,6 +17,11 @@ describe('AuthService', () => {
     user_id: 'user-123',
     email: 'test@example.com',
     password_hash: 'hashed-password',
+    failed_login_attempts: 0,
+    last_failed_login: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
+    refresh_token: null,
   };
   const mockUserProfile: UserProfile = {
     user: mockUser,
@@ -205,7 +210,7 @@ describe('AuthService', () => {
 
   describe('resetPassword', () => {
     it('should process password reset for existing user', async () => {
-      vi.mocked(userRepo.findUserByEmail).mockResolvedValue(mockUser as any);
+      vi.mocked(userRepo.findUserByEmail).mockResolvedValue(mockUser);
       vi.mocked(bcrypt.hash).mockImplementation(async () => 'hashed-token');
 
       const result = await authService.resetPassword('test@example.com', reqLog);
@@ -284,7 +289,7 @@ describe('AuthService', () => {
 
   describe('getUserByRefreshToken', () => {
     it('should return user profile if token exists', async () => {
-      vi.mocked(userRepo.findUserByRefreshToken).mockResolvedValue({ user_id: 'user-123' } as any);
+      vi.mocked(userRepo.findUserByRefreshToken).mockResolvedValue({ user_id: 'user-123', email: 'test@example.com', created_at: new Date().toISOString(), updated_at: new Date().toISOString() });
       vi.mocked(userRepo.findUserProfileById).mockResolvedValue(mockUserProfile);
 
       const result = await authService.getUserByRefreshToken('valid-token', reqLog);
@@ -318,7 +323,7 @@ describe('AuthService', () => {
 
   describe('refreshAccessToken', () => {
     it('should return new access token if user found', async () => {
-      vi.mocked(userRepo.findUserByRefreshToken).mockResolvedValue({ user_id: 'user-123' } as any);
+      vi.mocked(userRepo.findUserByRefreshToken).mockResolvedValue({ user_id: 'user-123', email: 'test@example.com', created_at: new Date().toISOString(), updated_at: new Date().toISOString() });
       vi.mocked(userRepo.findUserProfileById).mockResolvedValue(mockUserProfile);
       // FIX: The global mock for jsonwebtoken provides a `default` export.
       // The code under test (`authService`) uses `import jwt from 'jsonwebtoken'`, so it gets the default export.

src/services/db/admin.db.test.ts

@@ -203,7 +203,11 @@ describe('Admin DB Service', () => {
         .mockRejectedValueOnce(new Error('DB Read Error'));
 
       // The Promise.all should reject, and the function should re-throw the error
-      await expect(adminRepo.getApplicationStats(mockLogger)).rejects.toThrow('DB Read Error');
+      // The handleDbError function wraps the original error in a new one with a default message,
+      // so we should test for that specific message.
+      await expect(adminRepo.getApplicationStats(mockLogger)).rejects.toThrow(
+        'Failed to retrieve application statistics.',
+      );
       expect(mockLogger.error).toHaveBeenCalledWith(
         { err: expect.any(Error) },
         'Database error in getApplicationStats',
@@ -277,7 +281,7 @@ describe('Admin DB Service', () => {
         'Failed to get most frequent sale items.',
       );
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError },
+        { err: dbError, days: 30, limit: 10 },
         'Database error in getMostFrequentSaleItems',
       );
     });
@@ -688,7 +692,9 @@ describe('Admin DB Service', () => {
     it('should re-throw a generic error if the database query fails for other reasons', async () => {
       const dbError = new Error('DB Error');
       mockDb.query.mockRejectedValue(dbError);
-      await expect(adminRepo.updateUserRole('1', 'admin', mockLogger)).rejects.toThrow('DB Error');
+      await expect(adminRepo.updateUserRole('1', 'admin', mockLogger)).rejects.toThrow(
+        'Failed to update user role.',
+      );
       expect(mockLogger.error).toHaveBeenCalledWith(
         { err: dbError, userId: '1', role: 'admin' },
         'Database error in updateUserRole',

src/services/db/admin.db.ts

@@ -41,6 +41,7 @@ export class AdminRepository {
         sc.correction_type,
         sc.suggested_value,
         sc.status,
+        sc.updated_at,
         sc.created_at,
         fi.item as flyer_item_name,
         fi.price_display as flyer_item_price_display,
@@ -308,6 +309,7 @@ export class AdminRepository {
       SELECT
         ufi.unmatched_flyer_item_id,
         ufi.status,
+        ufi.updated_at,
         ufi.created_at,
         fi.flyer_item_id as flyer_item_id,
         fi.item as flyer_item_name,

src/services/db/budget.db.test.ts

@@ -249,6 +249,17 @@ describe('Budget DB Service', () => {
       expect(result).toEqual(mockUpdatedBudget);
     });
 
+    it('should prevent a user from updating a budget they do not own', async () => {
+      // Arrange: Mock the query to return 0 rows affected
+      mockDb.query.mockResolvedValue({ rows: [], rowCount: 0 });
+
+      // Act & Assert: Attempt to update with a different user ID should throw an error.
+      await expect(
+        budgetRepo.updateBudget(1, 'another-user', { name: 'Updated Groceries' }, mockLogger),
+      ).rejects.toThrow('Budget not found or user does not have permission to update.');
+    });
+
+
     it('should throw an error if no rows are updated', async () => {
       // Arrange: Mock the query to return 0 rows affected
       mockDb.query.mockResolvedValue({ rows: [], rowCount: 0 });

src/services/db/conversion.db.test.ts

@@ -0,0 +1,160 @@
+// src/services/db/conversion.db.test.ts
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { mockPoolInstance } from '../../tests/setup/tests-setup-unit';
+import { getPool } from './connection.db';
+import { conversionRepo } from './conversion.db';
+import { NotFoundError } from './errors.db';
+import type { UnitConversion } from '../../types';
+
+// Un-mock the module we are testing
+vi.unmock('./conversion.db');
+
+// Mock dependencies
+vi.mock('./connection.db', () => ({
+  getPool: vi.fn(),
+}));
+
+vi.mock('../logger.server', () => ({
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+
+import { logger as mockLogger } from '../logger.server';
+
+describe('Conversion DB Service', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Make getPool return our mock instance for each test
+    vi.mocked(getPool).mockReturnValue(mockPoolInstance as any);
+  });
+
+  describe('getConversions', () => {
+    it('should return all conversions if no filters are provided', async () => {
+      const mockConversions: UnitConversion[] = [
+        {
+          unit_conversion_id: 1,
+          master_item_id: 1,
+          from_unit: 'g',
+          to_unit: 'kg',
+          factor: 0.001,
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+        },
+      ];
+      mockPoolInstance.query.mockResolvedValue({ rows: mockConversions });
+
+      const result = await conversionRepo.getConversions({}, mockLogger);
+
+      expect(mockPoolInstance.query).toHaveBeenCalledWith(
+        expect.stringContaining('SELECT * FROM public.unit_conversions'),
+        expect.any(Array),
+      );
+      // Check that WHERE clause is not present for master_item_id
+      expect(mockPoolInstance.query.mock.calls[0][0]).not.toContain('WHERE master_item_id');
+      expect(result).toEqual(mockConversions);
+    });
+
+    it('should filter by masterItemId', async () => {
+      mockPoolInstance.query.mockResolvedValue({ rows: [] });
+
+      await conversionRepo.getConversions({ masterItemId: 123 }, mockLogger);
+
+      expect(mockPoolInstance.query).toHaveBeenCalledWith(
+        expect.stringContaining('WHERE master_item_id = $1'),
+        [123],
+      );
+    });
+
+    it('should throw an error if the database query fails', async () => {
+      const dbError = new Error('DB Error');
+      mockPoolInstance.query.mockRejectedValue(dbError);
+
+      await expect(conversionRepo.getConversions({}, mockLogger)).rejects.toThrow(
+        'Failed to retrieve unit conversions.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { err: dbError, filters: {} },
+        'Database error in getConversions',
+      );
+    });
+  });
+
+  describe('createConversion', () => {
+    const newConversion = {
+      master_item_id: 1,
+      from_unit: 'cup',
+      to_unit: 'ml',
+      factor: 236.588,
+    };
+
+    it('should insert a new conversion and return it', async () => {
+      const mockCreatedConversion: UnitConversion = {
+        unit_conversion_id: 1,
+        ...newConversion,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
+      mockPoolInstance.query.mockResolvedValue({ rows: [mockCreatedConversion] });
+
+      const result = await conversionRepo.createConversion(newConversion, mockLogger);
+
+      expect(mockPoolInstance.query).toHaveBeenCalledWith(
+        expect.stringContaining('INSERT INTO public.unit_conversions'),
+        [1, 'cup', 'ml', 236.588],
+      );
+      expect(result).toEqual(mockCreatedConversion);
+    });
+
+    it('should throw an error if the database query fails', async () => {
+      const dbError = new Error('DB Error');
+      mockPoolInstance.query.mockRejectedValue(dbError);
+
+      await expect(conversionRepo.createConversion(newConversion, mockLogger)).rejects.toThrow(
+        'Failed to create unit conversion.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { err: dbError, conversionData: newConversion },
+        'Database error in createConversion',
+      );
+    });
+  });
+
+  describe('deleteConversion', () => {
+    it('should delete a conversion if found', async () => {
+      mockPoolInstance.query.mockResolvedValue({ rowCount: 1 });
+
+      await conversionRepo.deleteConversion(1, mockLogger);
+
+      expect(mockPoolInstance.query).toHaveBeenCalledWith(
+        'DELETE FROM public.unit_conversions WHERE unit_conversion_id = $1',
+        [1],
+      );
+    });
+
+    it('should throw NotFoundError if conversion is not found', async () => {
+      mockPoolInstance.query.mockResolvedValue({ rowCount: 0 });
+
+      await expect(conversionRepo.deleteConversion(999, mockLogger)).rejects.toThrow(NotFoundError);
+      await expect(conversionRepo.deleteConversion(999, mockLogger)).rejects.toThrow(
+        'Unit conversion with ID 999 not found.',
+      );
+    });
+
+    it('should throw an error if the database query fails', async () => {
+      const dbError = new Error('DB Error');
+      mockPoolInstance.query.mockRejectedValue(dbError);
+
+      await expect(conversionRepo.deleteConversion(1, mockLogger)).rejects.toThrow(
+        'Failed to delete unit conversion.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { err: dbError, conversionId: 1 },
+        'Database error in deleteConversion',
+      );
+    });
+  });
+});

src/services/db/deals.db.test.ts

@@ -82,15 +82,15 @@ describe('Deals DB Service', () => {
       expect(result).toEqual([]);
     });
 
-    it('should re-throw the error if the database query fails', async () => {
+    it('should throw a generic error if the database query fails', async () => {
       const dbError = new Error('DB Connection Error');
       mockDb.query.mockRejectedValue(dbError);
 
       await expect(dealsRepo.findBestPricesForWatchedItems('user-1', mockLogger)).rejects.toThrow(
-        dbError,
+        'Failed to find best prices for watched items.',
       );
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError },
+        { err: dbError, userId: 'user-1' },
         'Database error in findBestPricesForWatchedItems',
       );
     });

src/services/db/flyer.db.test.ts

@@ -274,7 +274,7 @@ describe('Flyer DB Service', () => {
         ForeignKeyConstraintError,
       );
       await expect(flyerRepo.insertFlyerItems(999, itemsData, mockLogger)).rejects.toThrow(
-        'The specified flyer does not exist.',
+        'The specified flyer, category, master item, or product does not exist.',
       );
       expect(mockLogger.error).toHaveBeenCalledWith(
         { err: dbError, flyerId: 999 },
@@ -285,10 +285,10 @@ describe('Flyer DB Service', () => {
     it('should throw a generic error if the database query fails', async () => {
       const dbError = new Error('DB Connection Error');
       mockPoolInstance.query.mockRejectedValue(dbError);
-      // The implementation now re-throws the original error, so we should expect that.
+      // The implementation wraps the error using handleDbError
       await expect(
         flyerRepo.insertFlyerItems(1, [{ item: 'Test' } as FlyerItemInsert], mockLogger),
-      ).rejects.toThrow(dbError);
+      ).rejects.toThrow('An unknown error occurred while inserting flyer items.');
       expect(mockLogger.error).toHaveBeenCalledWith(
         { err: dbError, flyerId: 1 },
         'Database error in insertFlyerItems',
@@ -691,11 +691,7 @@ describe('Flyer DB Service', () => {
       );
 
       await expect(flyerRepo.deleteFlyer(999, mockLogger)).rejects.toThrow(
-        'Failed to delete flyer.',
-      );
-      expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: expect.any(NotFoundError), flyerId: 999 },
-        'Database transaction error in deleteFlyer',
+        'Flyer with ID 999 not found.',
       );
     });
 

src/services/db/flyer.db.ts

@@ -97,16 +97,23 @@ export class FlyerRepository {
         flyerData.store_address, // $8
         flyerData.status, // $9
         flyerData.item_count, // $10
-        flyerData.uploaded_by, // $11
+        flyerData.uploaded_by ?? null, // $11
       ];
 
       const result = await this.db.query<Flyer>(query, values);
       return result.rows[0];
     } catch (error) {
+      const isChecksumError =
+        error instanceof Error && error.message.includes('flyers_checksum_check');
+
       handleDbError(error, logger, 'Database error in insertFlyer', { flyerData }, {
         uniqueMessage: 'A flyer with this checksum already exists.',
         fkMessage: 'The specified user or store for this flyer does not exist.',
-        checkMessage: 'Invalid status provided for flyer.',
+        // Provide a more specific message for the checksum constraint violation,
+        // which is a common issue during seeding or testing with placeholder data.
+        checkMessage: isChecksumError
+          ? 'The provided checksum is invalid or does not meet format requirements (e.g., must be a 64-character SHA-256 hash).'
+          : 'Invalid status provided for flyer.',
         defaultMessage: 'Failed to insert flyer into database.',
       });
     }
@@ -173,7 +180,7 @@ export class FlyerRepository {
   async getAllBrands(logger: Logger): Promise<Brand[]> {
     try {
       const query = `
-        SELECT s.store_id as brand_id, s.name, s.logo_url
+        SELECT s.store_id as brand_id, s.name, s.logo_url, s.created_at, s.updated_at
         FROM public.stores s
         ORDER BY s.name;
       `;

src/services/db/gamification.db.ts

@@ -50,7 +50,8 @@ export class GamificationRepository {
           a.name,
           a.description,
           a.icon,
-          a.points_value
+          a.points_value,
+          a.created_at
         FROM public.user_achievements ua
         JOIN public.achievements a ON ua.achievement_id = a.achievement_id
         WHERE ua.user_id = $1

src/services/db/notification.db.test.ts

@@ -195,7 +195,7 @@ describe('Notification DB Service', () => {
         notificationRepo.createBulkNotifications(notificationsToCreate, mockLogger),
       ).rejects.toThrow(ForeignKeyConstraintError);
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError },
+        { err: dbError, notifications: notificationsToCreate },
         'Database error in createBulkNotifications',
       );
     });
@@ -208,7 +208,7 @@ describe('Notification DB Service', () => {
         notificationRepo.createBulkNotifications(notificationsToCreate, mockLogger),
       ).rejects.toThrow('Failed to create bulk notifications.');
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError },
+        { err: dbError, notifications: notificationsToCreate },
         'Database error in createBulkNotifications',
       );
     });
@@ -264,6 +264,16 @@ describe('Notification DB Service', () => {
     });
   });
 
+  describe('markNotificationAsRead - Ownership Check', () => {
+    it('should not mark a notification as read if the user does not own it', async () => {
+      mockPoolInstance.query.mockResolvedValue({ rowCount: 0 });
+
+      await expect(notificationRepo.markNotificationAsRead(1, 'wrong-user', mockLogger)).rejects.toThrow(
+        'Notification not found or user does not have permission.',
+      );
+    });
+  });
+
   describe('markAllNotificationsAsRead', () => {
     it('should execute an UPDATE query to mark all notifications as read for a user', async () => {
       mockPoolInstance.query.mockResolvedValue({ rowCount: 3 });

src/services/db/personalization.db.test.ts

@@ -5,7 +5,7 @@ import type { Pool, PoolClient } from 'pg';
 import { withTransaction } from './connection.db';
 import { PersonalizationRepository } from './personalization.db';
 import type { MasterGroceryItem, UserAppliance, DietaryRestriction, Appliance } from '../../types';
-import { createMockMasterGroceryItem } from '../../tests/utils/mockFactories';
+import { createMockMasterGroceryItem, createMockUserAppliance } from '../../tests/utils/mockFactories';
 
 // Un-mock the module we are testing to ensure we use the real implementation.
 vi.unmock('./personalization.db');
@@ -46,9 +46,6 @@ describe('Personalization DB Service', () => {
 
   describe('getAllMasterItems', () => {
     it('should execute the correct query and return master items', async () => {
-      console.log(
-        '[TEST DEBUG] Running test: getAllMasterItems > should execute the correct query',
-      );
       const mockItems: MasterGroceryItem[] = [
         createMockMasterGroceryItem({ master_grocery_item_id: 1, name: 'Apples' }),
       ];
@@ -64,8 +61,6 @@ describe('Personalization DB Service', () => {
         LEFT JOIN public.categories c ON mgi.category_id = c.category_id
         ORDER BY mgi.name ASC`;
 
-      console.log('[TEST DEBUG] mockQuery calls:', JSON.stringify(mockQuery.mock.calls, null, 2));
-
       // The query string in the implementation has a lot of whitespace from the template literal.
       // This updated expectation matches the new query exactly.
       expect(mockQuery).toHaveBeenCalledWith(expectedQuery);
@@ -649,8 +644,8 @@ describe('Personalization DB Service', () => {
   describe('setUserAppliances', () => {
     it('should execute a transaction to set appliances', async () => {
       const mockNewAppliances: UserAppliance[] = [
-        { user_id: 'user-123', appliance_id: 1 },
-        { user_id: 'user-123', appliance_id: 2 },
+        createMockUserAppliance({ user_id: 'user-123', appliance_id: 1 }),
+        createMockUserAppliance({ user_id: 'user-123', appliance_id: 2 }),
       ];
       const mockClientQuery = vi.fn();
       vi.mocked(withTransaction).mockImplementation(async (callback) => {

src/services/db/reaction.db.test.ts

@@ -0,0 +1,225 @@
+// src/services/db/reaction.db.test.ts
+import { describe, it, expect, vi, beforeEach, Mock } from 'vitest';
+import type { Pool, PoolClient } from 'pg';
+import { ReactionRepository } from './reaction.db';
+import { mockPoolInstance } from '../../tests/setup/tests-setup-unit';
+import { withTransaction } from './connection.db';
+import { ForeignKeyConstraintError } from './errors.db';
+import type { UserReaction } from '../../types';
+
+// Un-mock the module we are testing
+vi.unmock('./reaction.db');
+
+// Mock dependencies
+vi.mock('../logger.server', () => ({
+  logger: {
+    info: vi.fn(),
+    warn: vi.fn(),
+    error: vi.fn(),
+    debug: vi.fn(),
+  },
+}));
+import { logger as mockLogger } from '../logger.server';
+
+vi.mock('./connection.db', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('./connection.db')>();
+  return { ...actual, withTransaction: vi.fn() };
+});
+
+describe('Reaction DB Service', () => {
+  let reactionRepo: ReactionRepository;
+  const mockDb = {
+    query: vi.fn(),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    reactionRepo = new ReactionRepository(mockDb);
+  });
+
+  describe('getReactions', () => {
+    it('should build a query with no filters', async () => {
+      mockDb.query.mockResolvedValue({ rows: [] });
+      await reactionRepo.getReactions({}, mockLogger);
+      expect(mockDb.query).toHaveBeenCalledWith(
+        'SELECT * FROM public.user_reactions WHERE 1=1 ORDER BY created_at DESC',
+        [],
+      );
+    });
+
+    it('should build a query with a userId filter', async () => {
+      mockDb.query.mockResolvedValue({ rows: [] });
+      await reactionRepo.getReactions({ userId: 'user-1' }, mockLogger);
+      expect(mockDb.query).toHaveBeenCalledWith(
+        'SELECT * FROM public.user_reactions WHERE 1=1 AND user_id = $1 ORDER BY created_at DESC',
+        ['user-1'],
+      );
+    });
+
+    it('should build a query with all filters', async () => {
+      mockDb.query.mockResolvedValue({ rows: [] });
+      await reactionRepo.getReactions(
+        { userId: 'user-1', entityType: 'recipe', entityId: '123' },
+        mockLogger,
+      );
+      expect(mockDb.query).toHaveBeenCalledWith(
+        'SELECT * FROM public.user_reactions WHERE 1=1 AND user_id = $1 AND entity_type = $2 AND entity_id = $3 ORDER BY created_at DESC',
+        ['user-1', 'recipe', '123'],
+      );
+    });
+
+    it('should return an array of reactions on success', async () => {
+      const mockReactions: UserReaction[] = [
+        {
+          reaction_id: 1,
+          user_id: 'user-1',
+          entity_type: 'recipe',
+          entity_id: '123',
+          reaction_type: 'like',
+          created_at: new Date().toISOString(),
+          updated_at: new Date().toISOString(),
+        },
+      ];
+      mockDb.query.mockResolvedValue({ rows: mockReactions });
+      const result = await reactionRepo.getReactions({}, mockLogger);
+      expect(result).toEqual(mockReactions);
+    });
+
+    it('should throw an error if the database query fails', async () => {
+      const dbError = new Error('DB Error');
+      mockDb.query.mockRejectedValue(dbError);
+      await expect(reactionRepo.getReactions({}, mockLogger)).rejects.toThrow(
+        'Failed to retrieve user reactions.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { err: dbError, filters: {} },
+        'Database error in getReactions',
+      );
+    });
+  });
+
+  describe('toggleReaction', () => {
+    const reactionData = {
+      user_id: 'user-1',
+      entity_type: 'recipe',
+      entity_id: '123',
+      reaction_type: 'like',
+    };
+
+    it('should remove an existing reaction and return null', async () => {
+      const mockClient = { query: vi.fn() };
+      // Mock DELETE returning 1 row, indicating a reaction was deleted
+      (mockClient.query as Mock).mockResolvedValueOnce({ rowCount: 1 });
+
+      vi.mocked(withTransaction).mockImplementation(async (callback) => {
+        return callback(mockClient as unknown as PoolClient);
+      });
+
+      const result = await reactionRepo.toggleReaction(reactionData, mockLogger);
+
+      expect(result).toBeNull();
+      expect(mockClient.query).toHaveBeenCalledWith(
+        'DELETE FROM public.user_reactions WHERE user_id = $1 AND entity_type = $2 AND entity_id = $3 AND reaction_type = $4',
+        ['user-1', 'recipe', '123', 'like'],
+      );
+      // Ensure INSERT was not called
+      expect(mockClient.query).toHaveBeenCalledTimes(1);
+    });
+
+    it('should add a new reaction and return it if it does not exist', async () => {
+      const mockClient = { query: vi.fn() };
+      const mockCreatedReaction: UserReaction = {
+        reaction_id: 1,
+        ...reactionData,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
+
+      // Mock DELETE returning 0 rows, then mock INSERT returning the new reaction
+      (mockClient.query as Mock)
+        .mockResolvedValueOnce({ rowCount: 0 }) // DELETE
+        .mockResolvedValueOnce({ rows: [mockCreatedReaction] }); // INSERT
+
+      vi.mocked(withTransaction).mockImplementation(async (callback) => {
+        return callback(mockClient as unknown as PoolClient);
+      });
+
+      const result = await reactionRepo.toggleReaction(reactionData, mockLogger);
+
+      expect(result).toEqual(mockCreatedReaction);
+      expect(mockClient.query).toHaveBeenCalledTimes(2);
+      expect(mockClient.query).toHaveBeenCalledWith(
+        'INSERT INTO public.user_reactions (user_id, entity_type, entity_id, reaction_type) VALUES ($1, $2, $3, $4) RETURNING *',
+        ['user-1', 'recipe', '123', 'like'],
+      );
+    });
+
+    it('should throw ForeignKeyConstraintError if user or entity does not exist', async () => {
+      const dbError = new Error('violates foreign key constraint');
+      (dbError as Error & { code: string }).code = '23503';
+
+      vi.mocked(withTransaction).mockImplementation(async (callback) => {
+        const mockClient = { query: vi.fn().mockRejectedValue(dbError) };
+        await expect(callback(mockClient as unknown as PoolClient)).rejects.toThrow(dbError);
+        throw dbError;
+      });
+
+      await expect(reactionRepo.toggleReaction(reactionData, mockLogger)).rejects.toThrow(
+        ForeignKeyConstraintError,
+      );
+      await expect(reactionRepo.toggleReaction(reactionData, mockLogger)).rejects.toThrow(
+        'The specified user or entity does not exist.',
+      );
+    });
+
+    it('should throw a generic error if the transaction fails', async () => {
+      const dbError = new Error('Transaction failed');
+      vi.mocked(withTransaction).mockRejectedValue(dbError);
+
+      await expect(reactionRepo.toggleReaction(reactionData, mockLogger)).rejects.toThrow(
+        'Failed to toggle user reaction.',
+      );
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { err: dbError, reactionData },
+        'Database error in toggleReaction',
+      );
+    });
+  });
+
+  describe('getReactionSummary', () => {
+    it('should return a summary of reactions for an entity', async () => {
+      const mockSummary = [
+        { reaction_type: 'like', count: 5 },
+        { reaction_type: 'heart', count: 2 },
+      ];
+      // This method uses getPool() directly, so we mock the main instance
+      mockPoolInstance.query.mockResolvedValue({ rows: mockSummary });
+
+      const result = await reactionRepo.getReactionSummary('recipe', '123', mockLogger);
+
+      expect(result).toEqual(mockSummary);
+      expect(mockPoolInstance.query).toHaveBeenCalledWith(
+        expect.stringContaining('GROUP BY reaction_type'),
+        ['recipe', '123'],
+      );
+    });
+
+    it('should return an empty array if there are no reactions', async () => {
+      mockPoolInstance.query.mockResolvedValue({ rows: [] });
+      const result = await reactionRepo.getReactionSummary('recipe', '456', mockLogger);
+      expect(result).toEqual([]);
+    });
+
+    it('should throw an error if the database query fails', async () => {
+      const dbError = new Error('DB Error');
+      mockPoolInstance.query.mockRejectedValue(dbError);
+      await expect(
+        reactionRepo.getReactionSummary('recipe', '123', mockLogger),
+      ).rejects.toThrow('Failed to retrieve reaction summary.');
+      expect(mockLogger.error).toHaveBeenCalledWith(
+        { err: dbError, entityType: 'recipe', entityId: '123' },
+        'Database error in getReactionSummary',
+      );
+    });
+  });
+});

src/services/db/recipe.db.test.ts

@@ -268,6 +268,17 @@ describe('Recipe DB Service', () => {
       );
     });
   });
+   describe('deleteRecipe - Ownership Check', () => {
+    it('should not delete recipe if the user does not own it and is not an admin', async () => {
+      mockQuery.mockResolvedValue({ rowCount: 0 });
+
+      await expect(recipeRepo.deleteRecipe(1, 'wrong-user', false, mockLogger)).rejects.toThrow(
+        'Recipe not found or user does not have permission to delete.',
+      );
+    });
+
+  });
+
 
   describe('updateRecipe', () => {
     it('should execute an UPDATE query with the correct fields', async () => {
@@ -382,6 +393,7 @@ describe('Recipe DB Service', () => {
         content: 'Great!',
         status: 'visible',
         created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
       };
       mockQuery.mockResolvedValue({ rows: [mockComment] });
 
@@ -441,10 +453,6 @@ describe('Recipe DB Service', () => {
       await expect(recipeRepo.forkRecipe('user-123', 1, mockLogger)).rejects.toThrow(
         'Recipe is not public and cannot be forked.',
       );
-      expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, userId: 'user-123', originalRecipeId: 1 },
-        'Database error in forkRecipe',
-      );
     });
 
     it('should throw a generic error if the database query fails', async () => {

src/services/db/recipe.db.ts

@@ -239,6 +239,10 @@ export class RecipeRepository {
       }
       return res.rows[0];
     } catch (error) {
+      // Explicitly re-throw the "No fields" error before it gets caught by the generic handler.
+      if (error instanceof Error && error.message === 'No fields provided to update.') {
+        throw error;
+      }
       handleDbError(error, logger, 'Database error in updateRecipe', { recipeId, userId, updates }, {
         defaultMessage: 'Failed to update recipe.',
       });
@@ -255,8 +259,20 @@ export class RecipeRepository {
       const query = `
         SELECT
           r.*,
-          COALESCE(json_agg(DISTINCT jsonb_build_object('recipe_ingredient_id', ri.recipe_ingredient_id, 'master_item_name', mgi.name, 'quantity', ri.quantity, 'unit', ri.unit)) FILTER (WHERE ri.recipe_ingredient_id IS NOT NULL), '[]') AS ingredients,
-          COALESCE(json_agg(DISTINCT jsonb_build_object('tag_id', t.tag_id, 'name', t.name)) FILTER (WHERE t.tag_id IS NOT NULL), '[]') AS tags
+          COALESCE(json_agg(DISTINCT jsonb_build_object(
+            'recipe_ingredient_id', ri.recipe_ingredient_id,
+            'master_item_name', mgi.name,
+            'quantity', ri.quantity,
+            'unit', ri.unit,
+            'created_at', ri.created_at,
+            'updated_at', ri.updated_at
+            )) FILTER (WHERE ri.recipe_ingredient_id IS NOT NULL), '[]') AS ingredients,
+          COALESCE(json_agg(DISTINCT jsonb_build_object(
+            'tag_id', t.tag_id,
+            'name', t.name,
+            'created_at', t.created_at,
+            'updated_at', t.updated_at
+            )) FILTER (WHERE t.tag_id IS NOT NULL), '[]') AS tags
         FROM public.recipes r
         LEFT JOIN public.recipe_ingredients ri ON r.recipe_id = ri.recipe_id
         LEFT JOIN public.master_grocery_items mgi ON ri.master_item_id = mgi.master_grocery_item_id

src/services/db/shopping.db.test.ts

@@ -166,7 +166,7 @@ describe('Shopping DB Service', () => {
     it('should throw an error if no rows are deleted (list not found or wrong user)', async () => {
       mockPoolInstance.query.mockResolvedValue({ rowCount: 0, rows: [], command: 'DELETE' });
       await expect(shoppingRepo.deleteShoppingList(999, 'user-1', mockLogger)).rejects.toThrow(
-        'Failed to delete shopping list.',
+        'Shopping list not found or user does not have permission to delete.',
       );
     });
 
@@ -190,13 +190,14 @@ describe('Shopping DB Service', () => {
 
       const result = await shoppingRepo.addShoppingListItem(
         1,
+        'user-1',
         { customItemName: 'Custom Item' },
         mockLogger,
       );
 
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
         expect.stringContaining('INSERT INTO public.shopping_list_items'),
-        [1, null, 'Custom Item'],
+        [1, null, 'Custom Item', 'user-1'],
       );
       expect(result).toEqual(mockItem);
     });
@@ -205,11 +206,11 @@ describe('Shopping DB Service', () => {
       const mockItem = createMockShoppingListItem({ master_item_id: 123 });
       mockPoolInstance.query.mockResolvedValue({ rows: [mockItem] });
 
-      const result = await shoppingRepo.addShoppingListItem(1, { masterItemId: 123 }, mockLogger);
+      const result = await shoppingRepo.addShoppingListItem(1, 'user-1', { masterItemId: 123 }, mockLogger);
 
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
         expect.stringContaining('INSERT INTO public.shopping_list_items'),
-        [1, 123, null],
+        [1, 123, null, 'user-1'],
       );
       expect(result).toEqual(mockItem);
     });
@@ -223,19 +224,20 @@ describe('Shopping DB Service', () => {
 
       const result = await shoppingRepo.addShoppingListItem(
         1,
+        'user-1',
         { masterItemId: 123, customItemName: 'Organic Apples' },
         mockLogger,
       );
 
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
         expect.stringContaining('INSERT INTO public.shopping_list_items'),
-        [1, 123, 'Organic Apples'],
+        [1, 123, 'Organic Apples', 'user-1'],
       );
       expect(result).toEqual(mockItem);
     });
 
     it('should throw an error if both masterItemId and customItemName are missing', async () => {
-      await expect(shoppingRepo.addShoppingListItem(1, {}, mockLogger)).rejects.toThrow(
+      await expect(shoppingRepo.addShoppingListItem(1, 'user-1', {}, mockLogger)).rejects.toThrow(
         'Either masterItemId or customItemName must be provided.',
       );
     });
@@ -244,19 +246,19 @@ describe('Shopping DB Service', () => {
       const dbError = new Error('violates foreign key constraint');
       (dbError as Error & { code: string }).code = '23503';
       mockPoolInstance.query.mockRejectedValue(dbError);
-      await expect(
-        shoppingRepo.addShoppingListItem(999, { masterItemId: 999 }, mockLogger),
-      ).rejects.toThrow('Referenced list or item does not exist.');
+      await expect(shoppingRepo.addShoppingListItem(999, 'user-1', { masterItemId: 999 }, mockLogger)).rejects.toThrow(
+        'Referenced list or item does not exist.',
+      );
     });
 
     it('should throw a generic error if the database query fails', async () => {
       const dbError = new Error('DB Connection Error');
       mockPoolInstance.query.mockRejectedValue(dbError);
       await expect(
-        shoppingRepo.addShoppingListItem(1, { customItemName: 'Test' }, mockLogger),
+        shoppingRepo.addShoppingListItem(1, 'user-1', { customItemName: 'Test' }, mockLogger),
       ).rejects.toThrow('Failed to add item to shopping list.');
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, listId: 1, item: { customItemName: 'Test' } },
+        { err: dbError, listId: 1, userId: 'user-1', item: { customItemName: 'Test' } },
         'Database error in addShoppingListItem',
       );
     });
@@ -269,13 +271,14 @@ describe('Shopping DB Service', () => {
 
       const result = await shoppingRepo.updateShoppingListItem(
         1,
+        'user-1',
         { is_purchased: true },
         mockLogger,
       );
 
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
-        'UPDATE public.shopping_list_items SET is_purchased = $1 WHERE shopping_list_item_id = $2 RETURNING *',
-        [true, 1],
+        expect.stringContaining('UPDATE public.shopping_list_items sli'),
+        [true, 1, 'user-1'],
       );
       expect(result).toEqual(mockItem);
     });
@@ -285,11 +288,11 @@ describe('Shopping DB Service', () => {
       const mockItem = createMockShoppingListItem({ shopping_list_item_id: 1, ...updates });
       mockPoolInstance.query.mockResolvedValue({ rows: [mockItem], rowCount: 1 });
 
-      const result = await shoppingRepo.updateShoppingListItem(1, updates, mockLogger);
+      const result = await shoppingRepo.updateShoppingListItem(1, 'user-1', updates, mockLogger);
 
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
-        'UPDATE public.shopping_list_items SET quantity = $1, is_purchased = $2, notes = $3 WHERE shopping_list_item_id = $4 RETURNING *',
-        [updates.quantity, updates.is_purchased, updates.notes, 1],
+        expect.stringContaining('UPDATE public.shopping_list_items sli'),
+        [updates.quantity, updates.is_purchased, updates.notes, 1, 'user-1'],
       );
       expect(result).toEqual(mockItem);
     });
@@ -297,13 +300,13 @@ describe('Shopping DB Service', () => {
     it('should throw an error if the item to update is not found', async () => {
       mockPoolInstance.query.mockResolvedValue({ rowCount: 0, rows: [], command: 'UPDATE' });
       await expect(
-        shoppingRepo.updateShoppingListItem(999, { quantity: 5 }, mockLogger),
+        shoppingRepo.updateShoppingListItem(999, 'user-1', { quantity: 5 }, mockLogger),
       ).rejects.toThrow('Shopping list item not found.');
     });
 
     it('should throw an error if no valid fields are provided to update', async () => {
       // The function should throw before even querying the database.
-      await expect(shoppingRepo.updateShoppingListItem(1, {}, mockLogger)).rejects.toThrow(
+      await expect(shoppingRepo.updateShoppingListItem(1, 'user-1', {}, mockLogger)).rejects.toThrow(
         'No valid fields to update.',
       );
     });
@@ -312,44 +315,65 @@ describe('Shopping DB Service', () => {
       const dbError = new Error('DB Connection Error');
       mockPoolInstance.query.mockRejectedValue(dbError);
       await expect(
-        shoppingRepo.updateShoppingListItem(1, { is_purchased: true }, mockLogger),
+        shoppingRepo.updateShoppingListItem(1, 'user-1', { is_purchased: true }, mockLogger),
       ).rejects.toThrow('Failed to update shopping list item.');
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, itemId: 1, updates: { is_purchased: true } },
+        { err: dbError, itemId: 1, userId: 'user-1', updates: { is_purchased: true } },
         'Database error in updateShoppingListItem',
       );
     });
   });
 
+  describe('updateShoppingListItem - Ownership Check', () => {
+    it('should not update an item if the user does not own the shopping list', async () => {
+      mockPoolInstance.query.mockResolvedValue({ rowCount: 0 });
+
+      await expect(
+        shoppingRepo.updateShoppingListItem(1, 'wrong-user', { is_purchased: true }, mockLogger),
+      ).rejects.toThrow('Shopping list item not found.');
+    });
+  });
+
+
   describe('removeShoppingListItem', () => {
     it('should delete an item if rowCount is 1', async () => {
       mockPoolInstance.query.mockResolvedValue({ rowCount: 1, rows: [], command: 'DELETE' });
-      await expect(shoppingRepo.removeShoppingListItem(1, mockLogger)).resolves.toBeUndefined();
+      await expect(shoppingRepo.removeShoppingListItem(1, 'user-1', mockLogger)).resolves.toBeUndefined();
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
-        'DELETE FROM public.shopping_list_items WHERE shopping_list_item_id = $1',
-        [1],
+        expect.stringContaining('DELETE FROM public.shopping_list_items sli'),
+        [1, 'user-1'],
       );
     });
 
     it('should throw an error if no rows are deleted (item not found)', async () => {
       mockPoolInstance.query.mockResolvedValue({ rowCount: 0, rows: [], command: 'DELETE' });
-      await expect(shoppingRepo.removeShoppingListItem(999, mockLogger)).rejects.toThrow(
-        'Shopping list item not found.',
+      await expect(shoppingRepo.removeShoppingListItem(999, 'user-1', mockLogger)).rejects.toThrow(
+        'Shopping list item not found or user does not have permission.',
       );
     });
 
     it('should throw a generic error if the database query fails', async () => {
       const dbError = new Error('DB Connection Error');
       mockPoolInstance.query.mockRejectedValue(dbError);
-      await expect(shoppingRepo.removeShoppingListItem(1, mockLogger)).rejects.toThrow(
+      await expect(shoppingRepo.removeShoppingListItem(1, 'user-1', mockLogger)).rejects.toThrow(
         'Failed to remove item from shopping list.',
       );
       expect(mockLogger.error).toHaveBeenCalledWith(
-        { err: dbError, itemId: 1 },
+        { err: dbError, itemId: 1, userId: 'user-1' },
         'Database error in removeShoppingListItem',
       );
     });
   });
+  describe('removeShoppingListItem - Ownership Check', () => {
+    it('should not remove an item if the user does not own the shopping list', async () => {
+      mockPoolInstance.query.mockResolvedValue({ rowCount: 0 });
+
+      await expect(shoppingRepo.removeShoppingListItem(1, 'wrong-user', mockLogger)).rejects.toThrow(
+        'Shopping list item not found or user does not have permission.',
+      );
+    });
+  });
+
 
   describe('completeShoppingList', () => {
     it('should call the complete_shopping_list database function', async () => {

src/services/db/shopping.db.ts

@@ -29,8 +29,7 @@ export class ShoppingRepository {
   async getShoppingLists(userId: string, logger: Logger): Promise<ShoppingList[]> {
     try {
       const query = `
-              SELECT
-                  sl.shopping_list_id, sl.name, sl.created_at,
+        SELECT sl.shopping_list_id, sl.name, sl.created_at, sl.updated_at,
                   COALESCE(json_agg(
                       json_build_object(
                           'shopping_list_item_id', sli.shopping_list_item_id,
@@ -40,6 +39,7 @@ export class ShoppingRepository {
                           'quantity', sli.quantity,
                           'is_purchased', sli.is_purchased,
                           'added_at', sli.added_at,
+                          'updated_at', sli.updated_at,
                           'master_item', json_build_object('name', mgi.name)
                       )
                   ) FILTER (WHERE sli.shopping_list_item_id IS NOT NULL), '[]'::json) as items
@@ -68,7 +68,7 @@ export class ShoppingRepository {
   async createShoppingList(userId: string, name: string, logger: Logger): Promise<ShoppingList> {
     try {
       const res = await this.db.query<ShoppingList>(
-        'INSERT INTO public.shopping_lists (user_id, name) VALUES ($1, $2) RETURNING shopping_list_id, user_id, name, created_at',
+        'INSERT INTO public.shopping_lists (user_id, name) VALUES ($1, $2) RETURNING shopping_list_id, user_id, name, created_at, updated_at',
         [userId, name],
       );
       return { ...res.rows[0], items: [] };
@@ -89,8 +89,7 @@ export class ShoppingRepository {
   async getShoppingListById(listId: number, userId: string, logger: Logger): Promise<ShoppingList> {
     try {
       const query = `
-        SELECT
-          sl.shopping_list_id, sl.name, sl.created_at,
+        SELECT sl.shopping_list_id, sl.name, sl.created_at, sl.updated_at,
           COALESCE(json_agg(
             json_build_object(
               'shopping_list_item_id', sli.shopping_list_item_id,
@@ -100,6 +99,7 @@ export class ShoppingRepository {
               'quantity', sli.quantity,
               'is_purchased', sli.is_purchased,
               'added_at', sli.added_at,
+              'updated_at', sli.updated_at,
               'master_item', json_build_object('name', mgi.name)
             )
           ) FILTER (WHERE sli.shopping_list_item_id IS NOT NULL), '[]'::json) as items
@@ -156,6 +156,7 @@ export class ShoppingRepository {
    */
   async addShoppingListItem(
     listId: number,
+    userId: string,
     item: { masterItemId?: number; customItemName?: string },
     logger: Logger,
   ): Promise<ShoppingListItem> {
@@ -165,13 +166,29 @@ export class ShoppingRepository {
     }
 
     try {
-      const res = await this.db.query<ShoppingListItem>(
-        'INSERT INTO public.shopping_list_items (shopping_list_id, master_item_id, custom_item_name) VALUES ($1, $2, $3) RETURNING *',
-        [listId, item.masterItemId ?? null, item.customItemName ?? null],
-      );
+      const query = `
+        INSERT INTO public.shopping_list_items (shopping_list_id, master_item_id, custom_item_name)
+        SELECT $1, $2, $3
+        WHERE EXISTS (
+          SELECT 1 FROM public.shopping_lists WHERE shopping_list_id = $1 AND user_id = $4
+        )
+        RETURNING *;
+      `;
+      const res = await this.db.query<ShoppingListItem>(query, [
+        listId,
+        item.masterItemId ?? null,
+        item.customItemName ?? null,
+        userId,
+      ]);
+
+      if (res.rowCount === 0) {
+        throw new NotFoundError('Shopping list not found or user does not have permission.');
+      }
+
       return res.rows[0];
     } catch (error) {
-      handleDbError(error, logger, 'Database error in addShoppingListItem', { listId, item }, {
+      if (error instanceof NotFoundError) throw error;
+      handleDbError(error, logger, 'Database error in addShoppingListItem', { listId, userId, item }, {
         fkMessage: 'Referenced list or item does not exist.',
         checkMessage: 'Shopping list item must have a master item or a custom name.',
         defaultMessage: 'Failed to add item to shopping list.',
@@ -183,19 +200,23 @@ export class ShoppingRepository {
    * Removes an item from a shopping list.
    * @param itemId The ID of the shopping list item to remove.
    */
-  async removeShoppingListItem(itemId: number, logger: Logger): Promise<void> {
+  async removeShoppingListItem(itemId: number, userId: string, logger: Logger): Promise<void> {
     try {
-      const res = await this.db.query(
-        'DELETE FROM public.shopping_list_items WHERE shopping_list_item_id = $1',
-        [itemId],
-      );
-      // The patch requested this specific error handling.
+      const query = `
+        DELETE FROM public.shopping_list_items sli
+        WHERE sli.shopping_list_item_id = $1
+          AND EXISTS (
+            SELECT 1 FROM public.shopping_lists sl
+            WHERE sl.shopping_list_id = sli.shopping_list_id AND sl.user_id = $2
+          );
+      `;
+      const res = await this.db.query(query, [itemId, userId]);
       if (res.rowCount === 0) {
-        throw new NotFoundError('Shopping list item not found.');
+        throw new NotFoundError('Shopping list item not found or user does not have permission.');
       }
     } catch (error) {
       if (error instanceof NotFoundError) throw error;
-      handleDbError(error, logger, 'Database error in removeShoppingListItem', { itemId }, {
+      handleDbError(error, logger, 'Database error in removeShoppingListItem', { itemId, userId }, {
         defaultMessage: 'Failed to remove item from shopping list.',
       });
     }
@@ -312,6 +333,7 @@ export class ShoppingRepository {
    */
   async updateShoppingListItem(
     itemId: number,
+    userId: string,
     updates: Partial<ShoppingListItem>,
     logger: Logger,
   ): Promise<ShoppingListItem> {
@@ -341,10 +363,19 @@ export class ShoppingRepository {
       }
 
       values.push(itemId);
-      const query = `UPDATE public.shopping_list_items SET ${setClauses.join(', ')} WHERE shopping_list_item_id = $${valueIndex} RETURNING *`;
+      values.push(userId);
+
+      const query = `
+        UPDATE public.shopping_list_items sli
+        SET ${setClauses.join(', ')}
+        FROM public.shopping_lists sl
+        WHERE sli.shopping_list_item_id = $${valueIndex}
+          AND sli.shopping_list_id = sl.shopping_list_id
+          AND sl.user_id = $${valueIndex + 1}
+        RETURNING sli.*;
+      `;
 
       const res = await this.db.query<ShoppingListItem>(query, values);
-      // The patch requested this specific error handling.
       if (res.rowCount === 0) {
         throw new NotFoundError('Shopping list item not found.');
       }
@@ -357,7 +388,7 @@ export class ShoppingRepository {
       ) {
         throw error;
       }
-      handleDbError(error, logger, 'Database error in updateShoppingListItem', { itemId, updates }, {
+      handleDbError(error, logger, 'Database error in updateShoppingListItem', { itemId, userId, updates }, {
         defaultMessage: 'Failed to update shopping list item.',
       });
     }
@@ -399,13 +430,15 @@ export class ShoppingRepository {
     try {
       const query = `
               SELECT
-                  st.shopping_trip_id, st.user_id, st.shopping_list_id, st.completed_at, st.total_spent_cents,
+                  st.shopping_trip_id, st.user_id, st.shopping_list_id, st.completed_at, st.total_spent_cents, st.updated_at,
                   COALESCE(
                       json_agg(
                           json_build_object(
                               'shopping_trip_item_id', sti.shopping_trip_item_id,
                               'master_item_id', sti.master_item_id,
                               'custom_item_name', sti.custom_item_name,
+                              'created_at', sti.created_at,
+                              'updated_at', sti.updated_at,
                               'quantity', sti.quantity,
                               'price_paid_cents', sti.price_paid_cents,
                               'master_item_name', mgi.name
@@ -462,7 +495,14 @@ export class ShoppingRepository {
     receiptId: number,
     items: Omit<
       ReceiptItem,
-      'receipt_item_id' | 'receipt_id' | 'status' | 'master_item_id' | 'product_id' | 'quantity'
+      | 'receipt_item_id'
+      | 'receipt_id'
+      | 'status'
+      | 'master_item_id'
+      | 'product_id'
+      | 'quantity'
+      | 'created_at'
+      | 'updated_at'
     >[],
     logger: Logger,
   ): Promise<void> {

src/services/db/user.db.test.ts

@@ -25,9 +25,9 @@ import { withTransaction } from './connection.db';
 import { UserRepository, exportUserData } from './user.db';
 
 import { mockPoolInstance } from '../../tests/setup/tests-setup-unit';
-import { createMockUserProfile } from '../../tests/utils/mockFactories';
+import { createMockUserProfile, createMockUser } from '../../tests/utils/mockFactories';
 import { UniqueConstraintError, ForeignKeyConstraintError, NotFoundError } from './errors.db';
-import type { Profile, ActivityLogItem, SearchQuery, UserProfile } from '../../types';
+import type { Profile, ActivityLogItem, SearchQuery, UserProfile, User } from '../../types';
 
 // Mock other db services that are used by functions in user.db.ts
 // Update mocks to put methods on prototype so spyOn works in exportUserData tests
@@ -70,7 +70,16 @@ describe('User DB Service', () => {
 
   describe('findUserByEmail', () => {
     it('should execute the correct query and return a user', async () => {
-      const mockUser = { user_id: '123', email: 'test@example.com' };
+      const mockUser = {
+        user_id: '123',
+        email: 'test@example.com',
+        password_hash: 'some-hash',
+        failed_login_attempts: 0,
+        last_failed_login: null,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        refresh_token: null,
+      };
       mockPoolInstance.query.mockResolvedValue({ rows: [mockUser] });
 
       const result = await userRepo.findUserByEmail('test@example.com', mockLogger);
@@ -107,8 +116,12 @@ describe('User DB Service', () => {
 
   describe('createUser', () => {
     it('should execute a transaction to create a user and profile', async () => {
-      const mockUser = { user_id: 'new-user-id', email: 'new@example.com' };
-      const now = new Date().toISOString();
+      const mockUser = {
+        user_id: 'new-user-id',
+        email: 'new@example.com',
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+      };
       // This is the flat structure returned by the DB query inside createUser
       const mockDbProfile = {
         user_id: 'new-user-id',
@@ -118,24 +131,31 @@ describe('User DB Service', () => {
         avatar_url: null,
         points: 0,
         preferences: null,
-        created_at: now,
-        updated_at: now,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        user_created_at: new Date().toISOString(),
+        user_updated_at: new Date().toISOString(),
       };
       // This is the nested structure the function is expected to return
       const expectedProfile: UserProfile = {
-        user: { user_id: 'new-user-id', email: 'new@example.com' },
+        user: {
+          user_id: mockDbProfile.user_id,
+          email: mockDbProfile.email,
+          created_at: mockDbProfile.user_created_at,
+          updated_at: mockDbProfile.user_updated_at,
+        },
         full_name: 'New User',
         avatar_url: null,
         role: 'user',
         points: 0,
         preferences: null,
-        created_at: now,
-        updated_at: now,
+        created_at: mockDbProfile.created_at,
+        updated_at: mockDbProfile.updated_at,
       };
 
-      vi.mocked(withTransaction).mockImplementation(async (callback) => {
-        const mockClient = { query: vi.fn() };
-        mockClient.query
+      vi.mocked(withTransaction).mockImplementation(async (callback: any) => {
+        const mockClient = { query: vi.fn(), release: vi.fn() };
+        (mockClient.query as Mock)
           .mockResolvedValueOnce({ rows: [] }) // set_config
           .mockResolvedValueOnce({ rows: [mockUser] }) // INSERT user
           .mockResolvedValueOnce({ rows: [mockDbProfile] }); // SELECT profile
@@ -149,16 +169,11 @@ describe('User DB Service', () => {
         mockLogger,
       );
 
-      console.log(
-        '[TEST DEBUG] createUser - Result from function:',
-        JSON.stringify(result, null, 2),
-      );
-      console.log(
-        '[TEST DEBUG] createUser - Expected result:',
-        JSON.stringify(expectedProfile, null, 2),
-      );
-
       // Use objectContaining because the real implementation might have other DB-generated fields.
+      // We can't do a deep equality check on the user object because the mock factory will generate different timestamps.
+      expect(result.user.user_id).toEqual(expectedProfile.user.user_id);
+      expect(result.full_name).toEqual(expectedProfile.full_name);
+      // eslint-disable-next-line @typescript-eslint/no-unused-vars
       expect(result).toEqual(expect.objectContaining(expectedProfile));
       expect(withTransaction).toHaveBeenCalledTimes(1);
     });
@@ -222,9 +237,7 @@ describe('User DB Service', () => {
       }
 
       expect(withTransaction).toHaveBeenCalledTimes(1);
-      expect(mockLogger.warn).toHaveBeenCalledWith(
-        `Attempted to create a user with an existing email: exists@example.com`,
-      );
+      expect(mockLogger.warn).toHaveBeenCalledWith(`Attempted to create a user with an existing email: exists@example.com`);
     });
 
     it('should throw an error if profile is not found after user creation', async () => {
@@ -255,8 +268,7 @@ describe('User DB Service', () => {
 
   describe('findUserWithProfileByEmail', () => {
     it('should query for a user and their profile by email', async () => {
-      const now = new Date().toISOString();
-      const mockDbResult = {
+      const mockDbResult: any = {
         user_id: '123',
         email: 'test@example.com',
         password_hash: 'hash',
@@ -268,9 +280,11 @@ describe('User DB Service', () => {
         role: 'user' as const,
         points: 0,
         preferences: null,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
+        user_created_at: new Date().toISOString(),
+        user_updated_at: new Date().toISOString(),
         address_id: null,
-        created_at: now,
-        updated_at: now,
       };
       mockPoolInstance.query.mockResolvedValue({ rows: [mockDbResult] });
 
@@ -281,9 +295,12 @@ describe('User DB Service', () => {
         points: 0,
         preferences: null,
         address_id: null,
-        created_at: now,
-        updated_at: now,
-        user: { user_id: '123', email: 'test@example.com' },
+        user: {
+          user_id: '123',
+          email: 'test@example.com',
+          created_at: expect.any(String),
+          updated_at: expect.any(String),
+        },
         password_hash: 'hash',
         failed_login_attempts: 0,
         last_failed_login: null,
@@ -292,15 +309,6 @@ describe('User DB Service', () => {
 
       const result = await userRepo.findUserWithProfileByEmail('test@example.com', mockLogger);
 
-      console.log(
-        '[TEST DEBUG] findUserWithProfileByEmail - Result from function:',
-        JSON.stringify(result, null, 2),
-      );
-      console.log(
-        '[TEST DEBUG] findUserWithProfileByEmail - Expected result:',
-        JSON.stringify(expectedResult, null, 2),
-      );
-
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
         expect.stringContaining('JOIN public.profiles'),
         ['test@example.com'],
@@ -329,7 +337,11 @@ describe('User DB Service', () => {
 
   describe('findUserById', () => {
     it('should query for a user by their ID', async () => {
-      mockPoolInstance.query.mockResolvedValue({ rows: [{ user_id: '123' }], rowCount: 1 });
+      const mockUser = createMockUser({ user_id: '123' });
+      mockPoolInstance.query.mockResolvedValue({
+        rows: [mockUser],
+        rowCount: 1,
+      });
       await userRepo.findUserById('123', mockLogger);
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
         expect.stringContaining('FROM public.users WHERE user_id = $1'),
@@ -359,13 +371,16 @@ describe('User DB Service', () => {
 
   describe('findUserWithPasswordHashById', () => {
     it('should query for a user and their password hash by ID', async () => {
+      const mockUser = createMockUser({ user_id: '123' });
+      const mockUserWithHash = { ...mockUser, password_hash: 'hash' };
+
       mockPoolInstance.query.mockResolvedValue({
-        rows: [{ user_id: '123', password_hash: 'hash' }],
+        rows: [mockUserWithHash],
         rowCount: 1,
       });
       await userRepo.findUserWithPasswordHashById('123', mockLogger);
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
-        expect.stringContaining('SELECT user_id, email, password_hash'),
+        expect.stringContaining('SELECT user_id, email, password_hash, created_at, updated_at'),
         ['123'],
       );
     });
@@ -395,7 +410,11 @@ describe('User DB Service', () => {
 
   describe('findUserProfileById', () => {
     it('should query for a user profile by user ID', async () => {
-      mockPoolInstance.query.mockResolvedValue({ rows: [{ user_id: '123' }] });
+      const mockProfile = createMockUserProfile({
+        user: createMockUser({ user_id: '123' }),
+      });
+      // The query returns a user object inside, so we need to mock that structure.
+      mockPoolInstance.query.mockResolvedValue({ rows: [mockProfile] });
       await userRepo.findUserProfileById('123', mockLogger);
       // The actual query uses 'p.user_id' due to the join alias
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
@@ -426,7 +445,7 @@ describe('User DB Service', () => {
 
   describe('updateUserProfile', () => {
     it('should execute an UPDATE query for the user profile', async () => {
-      const mockProfile: Profile = {
+      const mockProfile: any = {
         full_name: 'Updated Name',
         role: 'user',
         points: 0,
@@ -444,7 +463,7 @@ describe('User DB Service', () => {
     });
 
     it('should execute an UPDATE query for avatar_url', async () => {
-      const mockProfile: Profile = {
+      const mockProfile: any = {
         avatar_url: 'new-avatar.png',
         role: 'user',
         points: 0,
@@ -462,7 +481,7 @@ describe('User DB Service', () => {
     });
 
     it('should execute an UPDATE query for address_id', async () => {
-      const mockProfile: Profile = {
+      const mockProfile: any = {
         address_id: 99,
         role: 'user',
         points: 0,
@@ -480,8 +499,8 @@ describe('User DB Service', () => {
     });
 
     it('should fetch the current profile if no update fields are provided', async () => {
-      const mockProfile: Profile = createMockUserProfile({
-        user: { user_id: '123', email: '123@example.com' },
+      const mockProfile: UserProfile = createMockUserProfile({
+        user: createMockUser({ user_id: '123', email: '123@example.com' }),
         full_name: 'Current Name',
       });
       // FIX: Instead of mocking `mockResolvedValue` on the instance method which might fail if not spied correctly,
@@ -520,7 +539,7 @@ describe('User DB Service', () => {
 
   describe('updateUserPreferences', () => {
     it('should execute an UPDATE query for user preferences', async () => {
-      mockPoolInstance.query.mockResolvedValue({ rows: [{}] });
+      mockPoolInstance.query.mockResolvedValue({ rows: [createMockUserProfile()] });
       await userRepo.updateUserPreferences('123', { darkMode: true }, mockLogger);
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
         expect.stringContaining("SET preferences = COALESCE(preferences, '{}'::jsonb) || $1"),
@@ -616,7 +635,11 @@ describe('User DB Service', () => {
 
   describe('findUserByRefreshToken', () => {
     it('should query for a user by their refresh token', async () => {
-      mockPoolInstance.query.mockResolvedValue({ rows: [{ user_id: '123' }], rowCount: 1 });
+      const mockUser = createMockUser({ user_id: '123' });
+      mockPoolInstance.query.mockResolvedValue({
+        rows: [mockUser],
+        rowCount: 1,
+      });
       await userRepo.findUserByRefreshToken('a-token', mockLogger);
       expect(mockPoolInstance.query).toHaveBeenCalledWith(
         expect.stringContaining('WHERE refresh_token = $1'),
@@ -788,7 +811,7 @@ describe('User DB Service', () => {
 
       const findProfileSpy = vi.spyOn(UserRepository.prototype, 'findUserProfileById');
       findProfileSpy.mockResolvedValue(
-        createMockUserProfile({ user: { user_id: '123', email: '123@example.com' } }),
+        createMockUserProfile({ user: createMockUser({ user_id: '123', email: '123@example.com' }) }),
       );
       const getWatchedItemsSpy = vi.spyOn(PersonalizationRepository.prototype, 'getWatchedItems');
       getWatchedItemsSpy.mockResolvedValue([]);
@@ -815,9 +838,7 @@ describe('User DB Service', () => {
       );
 
       // Act & Assert: The outer function catches the NotFoundError and re-throws it.
-      await expect(exportUserData('123', mockLogger)).rejects.toThrow(
-        'Failed to export user data.',
-      );
+      await expect(exportUserData('123', mockLogger)).rejects.toThrow('Profile not found');
       expect(withTransaction).toHaveBeenCalledTimes(1);
     });
 
@@ -898,8 +919,8 @@ describe('User DB Service', () => {
           user_id: 'following-1',
           action: 'recipe_created',
           display_text: 'Created a new recipe',
-          created_at: new Date().toISOString(),
           details: { recipe_id: 1, recipe_name: 'Test Recipe' },
+          created_at: new Date().toISOString(),
           updated_at: new Date().toISOString(),
         },
       ];
@@ -935,16 +956,17 @@ describe('User DB Service', () => {
 
   describe('logSearchQuery', () => {
     it('should execute an INSERT query and return the new search query log', async () => {
-      const queryData: Omit<SearchQuery, 'search_query_id' | 'created_at'> = {
+      const queryData: Omit<SearchQuery, 'search_query_id' | 'created_at' | 'updated_at'> = {
         user_id: 'user-123',
         query_text: 'best chicken recipes',
         result_count: 5,
         was_successful: true,
       };
-      const mockLoggedQuery: SearchQuery = {
+      const mockLoggedQuery: any = {
         search_query_id: 1,
-        created_at: new Date().toISOString(),
         ...queryData,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
       };
       mockPoolInstance.query.mockResolvedValue({ rows: [mockLoggedQuery] });
 
@@ -966,8 +988,9 @@ describe('User DB Service', () => {
       };
       const mockLoggedQuery: SearchQuery = {
         search_query_id: 2,
-        created_at: new Date().toISOString(),
         ...queryData,
+        created_at: new Date().toISOString(),
+        updated_at: new Date().toISOString(),
       };
       mockPoolInstance.query.mockResolvedValue({ rows: [mockLoggedQuery] });
 

src/services/db/user.db.ts

@@ -2,7 +2,7 @@
 import { Pool, PoolClient } from 'pg';
 import { getPool } from './connection.db';
 import type { Logger } from 'pino';
-import { NotFoundError, handleDbError } from './errors.db';
+import { NotFoundError, handleDbError, UniqueConstraintError } from './errors.db';
 import {
   Profile,
   MasterGroceryItem,
@@ -10,6 +10,7 @@ import {
   ActivityLogItem,
   UserProfile,
   SearchQuery,
+  User,
 } from '../../types';
 import { ShoppingRepository } from './shopping.db';
 import { PersonalizationRepository } from './personalization.db';
@@ -26,6 +27,8 @@ interface DbUser {
   refresh_token?: string | null;
   failed_login_attempts: number;
   last_failed_login: string | null; // This will be a date string from the DB
+  created_at: string;
+  updated_at: string;
 }
 
 export class UserRepository {
@@ -43,7 +46,7 @@ export class UserRepository {
     logger.debug({ email }, `[DB findUserByEmail] Searching for user.`);
     try {
       const res = await this.db.query<DbUser>(
-        'SELECT user_id, email, password_hash, refresh_token, failed_login_attempts, last_failed_login FROM public.users WHERE email = $1',
+        'SELECT user_id, email, password_hash, refresh_token, failed_login_attempts, last_failed_login, created_at, updated_at FROM public.users WHERE email = $1',
         [email],
       );
       const userFound = res.rows[0];
@@ -91,7 +94,7 @@ export class UserRepository {
 
       // After the trigger has run, fetch the complete profile data.
       const profileQuery = `
-        SELECT u.user_id, u.email, p.full_name, p.avatar_url, p.role, p.points, p.preferences, p.created_at, p.updated_at
+        SELECT u.user_id, u.email, u.created_at as user_created_at, u.updated_at as user_updated_at, p.full_name, p.avatar_url, p.role, p.points, p.preferences, p.created_at, p.updated_at
         FROM public.users u
         JOIN public.profiles p ON u.user_id = p.user_id
         WHERE u.user_id = $1;
@@ -109,6 +112,8 @@ export class UserRepository {
         user: {
           user_id: flatProfile.user_id,
           email: flatProfile.email,
+          created_at: flatProfile.user_created_at,
+          updated_at: flatProfile.user_updated_at,
         },
         full_name: flatProfile.full_name,
         avatar_url: flatProfile.avatar_url,
@@ -122,6 +127,12 @@ export class UserRepository {
       logger.debug({ user: fullUserProfile }, `[DB createUser] Fetched full profile for new user:`);
       return fullUserProfile;
     }).catch((error) => {
+      // Specific handling for unique constraint violation on user creation
+      if (error instanceof Error && 'code' in error && (error as any).code === '23505') {
+        logger.warn(`Attempted to create a user with an existing email: ${email}`);
+        throw new UniqueConstraintError('A user with this email address already exists.');
+      }
+      // Fallback to generic handler for all other errors
       handleDbError(error, logger, 'Error during createUser transaction', { email }, {
         uniqueMessage: 'A user with this email address already exists.',
         defaultMessage: 'Failed to create user in database.',
@@ -142,15 +153,17 @@ export class UserRepository {
     logger.debug({ email }, `[DB findUserWithProfileByEmail] Searching for user.`);
     try {
       const query = `
-        SELECT 
-          u.user_id, u.email, u.password_hash, u.refresh_token, u.failed_login_attempts, u.last_failed_login,
+        SELECT
+          u.user_id, u.email, u.created_at as user_created_at, u.updated_at as user_updated_at, u.password_hash, u.refresh_token, u.failed_login_attempts, u.last_failed_login,
           p.full_name, p.avatar_url, p.role, p.points, p.preferences, p.address_id,
           p.created_at, p.updated_at
         FROM public.users u
         JOIN public.profiles p ON u.user_id = p.user_id
         WHERE u.email = $1;
       `;
-      const res = await this.db.query<DbUser & Profile>(query, [email]);
+      const res = await this.db.query<
+        DbUser & Profile & { user_created_at: string; user_updated_at: string }
+      >(query, [email]);
       const flatUser = res.rows[0];
 
       if (!flatUser) {
@@ -170,6 +183,8 @@ export class UserRepository {
         user: {
           user_id: flatUser.user_id,
           email: flatUser.email,
+          created_at: flatUser.user_created_at,
+          updated_at: flatUser.user_updated_at,
         },
         password_hash: flatUser.password_hash,
         failed_login_attempts: flatUser.failed_login_attempts,
@@ -191,10 +206,10 @@ export class UserRepository {
    * @returns A promise that resolves to the user object (id, email) or undefined if not found.
    */
   // prettier-ignore
-  async findUserById(userId: string, logger: Logger): Promise<{ user_id: string; email: string; }> {
+  async findUserById(userId: string, logger: Logger): Promise<User> {
     try {
-      const res = await this.db.query<{ user_id: string; email: string }>(
-        'SELECT user_id, email FROM public.users WHERE user_id = $1',
+      const res = await this.db.query<User>(
+        'SELECT user_id, email, created_at, updated_at FROM public.users WHERE user_id = $1',
         [userId]
       );
       if (res.rowCount === 0) {
@@ -216,10 +231,10 @@ export class UserRepository {
    * @returns A promise that resolves to the user object (id, email, password_hash) or undefined if not found.
    */
   // prettier-ignore
-  async findUserWithPasswordHashById(userId: string, logger: Logger): Promise<{ user_id: string; email: string; password_hash: string | null }> {
+  async findUserWithPasswordHashById(userId: string, logger: Logger): Promise<User & { password_hash: string | null }> {
     try {
-      const res = await this.db.query<{ user_id: string; email: string; password_hash: string | null }>(
-        'SELECT user_id, email, password_hash FROM public.users WHERE user_id = $1',
+      const res = await this.db.query<User & { password_hash: string | null }>(
+        'SELECT user_id, email, password_hash, created_at, updated_at FROM public.users WHERE user_id = $1',
         [userId]
       );
       if ((res.rowCount ?? 0) === 0) {
@@ -247,7 +262,9 @@ export class UserRepository {
            p.created_at, p.updated_at,
            json_build_object(
              'user_id', u.user_id,
-             'email', u.email
+             'email', u.email,
+             'created_at', u.created_at,
+             'updated_at', u.updated_at
            ) as user,
            CASE
              WHEN a.address_id IS NOT NULL THEN json_build_object(
@@ -420,10 +437,10 @@ export class UserRepository {
   async findUserByRefreshToken(
     refreshToken: string,
     logger: Logger,
-  ): Promise<{ user_id: string; email: string } | undefined> {
+  ): Promise<User | undefined> {
     try {
-      const res = await this.db.query<{ user_id: string; email: string }>(
-        'SELECT user_id, email FROM public.users WHERE refresh_token = $1',
+      const res = await this.db.query<User>(
+        'SELECT user_id, email, created_at, updated_at FROM public.users WHERE refresh_token = $1',
         [refreshToken],
       );
       if ((res.rowCount ?? 0) === 0) {
@@ -605,7 +622,7 @@ export class UserRepository {
    * @returns A promise that resolves to the created SearchQuery object.
    */
   async logSearchQuery(
-    queryData: Omit<SearchQuery, 'search_query_id' | 'created_at'>,
+    queryData: Omit<SearchQuery, 'search_query_id' | 'created_at' | 'updated_at'>,
     logger: Logger,
   ): Promise<SearchQuery> {
     const { user_id, query_text, result_count, was_successful } = queryData;

src/services/flyerAiProcessor.server.test.ts

@@ -100,7 +100,7 @@ describe('FlyerAiProcessor', () => {
       valid_to: null,
       store_address: null,
     };
-    vi.mocked(mockAiService.extractCoreDataFromFlyerImage).mockResolvedValue(mockAiResponse as any);
+    vi.mocked(mockAiService.extractCoreDataFromFlyerImage).mockResolvedValue(mockAiResponse);
     const { logger } = await import('./logger.server');
 
     const imagePaths = [{ path: 'page1.jpg', mimetype: 'image/jpeg' }];

src/tests/integration/admin.integration.test.ts

@@ -164,8 +164,10 @@ describe('Admin API Routes Integration Tests', () => {
     beforeEach(async () => {
       const flyerRes = await getPool().query(
         `INSERT INTO public.flyers (store_id, file_name, image_url, item_count, checksum) 
-         VALUES ($1, 'admin-test.jpg', 'http://test.com/img.jpg', 1, $2) RETURNING flyer_id`,
-        [testStoreId, `checksum-${Date.now()}-${Math.random()}`],
+         VALUES ($1, 'admin-test.jpg', 'https://example.com/flyer-images/asdmin-test.jpg', 1, $2) RETURNING flyer_id`,
+        // The checksum must be a unique 64-character string to satisfy the DB constraint.
+        // We generate a dynamic string and pad it to 64 characters.
+        [testStoreId, `checksum-${Date.now()}-${Math.random()}`.padEnd(64, '0')],
       );
       const flyerId = flyerRes.rows[0].flyer_id;
 

src/tests/integration/flyer-processing.integration.test.ts

@@ -1,5 +1,5 @@
 // src/tests/integration/flyer-processing.integration.test.ts
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
 import supertest from 'supertest';
 import app from '../../../server';
 import fs from 'node:fs/promises';
@@ -8,7 +8,7 @@ import * as db from '../../services/db/index.db';
 import { getPool } from '../../services/db/connection.db';
 import { generateFileChecksum } from '../../utils/checksum';
 import { logger } from '../../services/logger.server';
-import type { UserProfile } from '../../types';
+import type { UserProfile, ExtractedFlyerItem } from '../../types';
 import { createAndLoginUser } from '../utils/testHelpers';
 import { cleanupDb } from '../utils/cleanup';
 import { cleanupFiles } from '../utils/cleanupFiles';
@@ -16,12 +16,16 @@ import piexif from 'piexifjs';
 import exifParser from 'exif-parser';
 import sharp from 'sharp';
 
+
 /**
  * @vitest-environment node
  */
 
 const request = supertest(app);
 
+// Import the mocked service to control its behavior in tests.
+import { aiService } from '../../services/aiService.server';
+
 describe('Flyer Processing Background Job Integration Test', () => {
   const createdUserIds: string[] = [];
   const createdFlyerIds: number[] = [];
@@ -29,6 +33,23 @@ describe('Flyer Processing Background Job Integration Test', () => {
 
   beforeAll(async () => {
     // This setup is now simpler as the worker handles fetching master items.
+    // Setup default mock response for AI service
+    const mockItems: ExtractedFlyerItem[] = [
+      {
+        item: 'Mocked Integration Item',
+        price_display: '$1.99',
+        price_in_cents: 199,
+        quantity: 'each',
+        category_name: 'Mock Category',
+      },
+    ];
+    vi.spyOn(aiService, 'extractCoreDataFromFlyerImage').mockResolvedValue({
+      store_name: 'Mock Store',
+      valid_from: null,
+      valid_to: null,
+      store_address: null,
+      items: mockItems,
+    });
   });
 
   afterAll(async () => {
@@ -80,7 +101,7 @@ describe('Flyer Processing Background Job Integration Test', () => {
 
     // Act 2: Poll for the job status until it completes.
     let jobStatus;
-    const maxRetries = 30; // Poll for up to 90 seconds (30 * 3s)
+    const maxRetries = 60; // Poll for up to 180 seconds (60 * 3s)
     for (let i = 0; i < maxRetries; i++) {
       console.log(`Polling attempt ${i + 1}...`);
       await new Promise((resolve) => setTimeout(resolve, 3000)); // Wait 3 seconds between polls
@@ -149,12 +170,12 @@ describe('Flyer Processing Background Job Integration Test', () => {
 
     // Act & Assert
     await runBackgroundProcessingTest(authUser, token);
-  }, 120000); // Increase timeout to 120 seconds for this long-running test
+  }, 240000); // Increase timeout to 240 seconds for this long-running test
 
   it('should successfully process a flyer for an ANONYMOUS user via the background queue', async () => {
     // Act & Assert: Call the test helper without a user or token.
     await runBackgroundProcessingTest();
-  }, 120000); // Increase timeout to 120 seconds for this long-running test
+  }, 240000); // Increase timeout to 240 seconds for this long-running test
 
   it(
     'should strip EXIF data from uploaded JPEG images during processing',
@@ -219,7 +240,7 @@ describe('Flyer Processing Background Job Integration Test', () => {
         console.error('[DEBUG] EXIF test job failed:', jobStatus.failedReason);
       }
       expect(jobStatus?.state).toBe('completed');
-      const flyerId = jobStatus?.returnValue?.flyerId;
+      const flyerId = jobStatus?.data?.flyerId;
       expect(flyerId).toBeTypeOf('number');
       createdFlyerIds.push(flyerId);
 
@@ -238,7 +259,7 @@ describe('Flyer Processing Background Job Integration Test', () => {
       expect(exifResult.tags).toEqual({});
       expect(exifResult.tags.Software).toBeUndefined();
     },
-    120000,
+    240000,
   );
 
   it(
@@ -305,7 +326,7 @@ describe('Flyer Processing Background Job Integration Test', () => {
         console.error('[DEBUG] PNG metadata test job failed:', jobStatus.failedReason);
       }
       expect(jobStatus?.state).toBe('completed');
-      const flyerId = jobStatus?.returnValue?.flyerId;
+      const flyerId = jobStatus?.data?.flyerId;
       expect(flyerId).toBeTypeOf('number');
       createdFlyerIds.push(flyerId);
 
@@ -322,6 +343,6 @@ describe('Flyer Processing Background Job Integration Test', () => {
       // The `exif` property should be undefined after the fix.
       expect(savedImageMetadata.exif).toBeUndefined();
     },
-    120000,
+    240000,
   );
 });

src/tests/integration/flyer.integration.test.ts

@@ -25,8 +25,8 @@ describe('Public Flyer API Routes Integration Tests', () => {
 
     const flyerRes = await getPool().query(
       `INSERT INTO public.flyers (store_id, file_name, image_url, item_count, checksum) 
-       VALUES ($1, 'integration-test.jpg', 'http://test.com/img.jpg', 1, $2) RETURNING flyer_id`,
-      [storeId, `checksum-${Date.now()}`],
+       VALUES ($1, 'integration-test.jpg', 'https://example.com/flyer-images/integration-test.jpg', 1, $2) RETURNING flyer_id`,
+      [storeId, `${Date.now().toString(16)}`.padEnd(64, '0')],
     );
     createdFlyerId = flyerRes.rows[0].flyer_id;
 

src/tests/integration/gamification.integration.test.ts

@@ -1,5 +1,5 @@
 // src/tests/integration/gamification.integration.test.ts
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
 import supertest from 'supertest';
 import app from '../../../server';
 import path from 'path';
@@ -9,7 +9,13 @@ import { generateFileChecksum } from '../../utils/checksum';
 import * as db from '../../services/db/index.db';
 import { cleanupDb } from '../utils/cleanup';
 import { logger } from '../../services/logger.server';
-import type { UserProfile, UserAchievement, LeaderboardUser, Achievement  } from '../../types';
+import type {
+  UserProfile,
+  UserAchievement,
+  LeaderboardUser,
+  Achievement,
+  ExtractedFlyerItem,
+} from '../../types';
 import { cleanupFiles } from '../utils/cleanupFiles';
 
 /**
@@ -18,6 +24,9 @@ import { cleanupFiles } from '../utils/cleanupFiles';
 
 const request = supertest(app);
 
+// Import the mocked service to control its behavior in tests.
+import { aiService } from '../../services/aiService.server';
+
 describe('Gamification Flow Integration Test', () => {
   let testUser: UserProfile;
   let authToken: string;
@@ -31,6 +40,28 @@ describe('Gamification Flow Integration Test', () => {
       fullName: 'Gamification Tester',
       request,
     }));
+
+    // Mock the AI service's method to prevent actual API calls during integration tests.
+    // This is crucial for making the integration test reliable. We don't want to
+    // depend on the external Gemini API, which has quotas and can be slow.
+    // By mocking this, we test our application's internal flow:
+    // API -> Queue -> Worker -> DB -> Gamification Logic
+    const mockExtractedItems: ExtractedFlyerItem[] = [
+      {
+        item: 'Integration Test Milk',
+        price_display: '$4.99',
+        price_in_cents: 499,
+        quantity: '2L',
+        category_name: 'Dairy',
+      },
+    ];
+    vi.spyOn(aiService, 'extractCoreDataFromFlyerImage').mockResolvedValue({
+      store_name: 'Gamification Test Store',
+      valid_from: null,
+      valid_to: null,
+      store_address: null,
+      items: mockExtractedItems,
+    });
   });
 
   afterAll(async () => {
@@ -81,12 +112,17 @@ describe('Gamification Flow Integration Test', () => {
           break;
         }
       }
+    if (!jobStatus) {
+      console.error('[DEBUG] Gamification test job timed out: No job status received.');
+      throw new Error('Gamification test job timed out: No job status received.');
+    }
 
       // --- Assert 1: Verify the job completed successfully ---
       if (jobStatus?.state === 'failed') {
         console.error('[DEBUG] Gamification test job failed:', jobStatus.failedReason);
       }
       expect(jobStatus?.state).toBe('completed');
+
       const flyerId = jobStatus?.returnValue?.flyerId;
       expect(flyerId).toBeTypeOf('number');
       createdFlyerIds.push(flyerId); // Track for cleanup

src/tests/integration/price.integration.test.ts

@@ -35,22 +35,22 @@ describe('Price History API Integration Test (/api/price-history)', () => {
     // 3. Create two flyers with different dates
     const flyerRes1 = await pool.query(
       `INSERT INTO public.flyers (store_id, file_name, image_url, item_count, checksum, valid_from) 
-       VALUES ($1, 'price-test-1.jpg', 'http://test.com/price-1.jpg', 1, $2, '2025-01-01') RETURNING flyer_id`,
-      [storeId, `checksum-price-1-${Date.now()}`],
+       VALUES ($1, 'price-test-1.jpg', 'https://example.com/flyer-images/price-test-1.jpg', 1, $2, '2025-01-01') RETURNING flyer_id`,
+      [storeId, `${Date.now().toString(16)}1`.padEnd(64, '0')],
     );
     flyerId1 = flyerRes1.rows[0].flyer_id;
 
     const flyerRes2 = await pool.query(
       `INSERT INTO public.flyers (store_id, file_name, image_url, item_count, checksum, valid_from) 
-       VALUES ($1, 'price-test-2.jpg', 'http://test.com/price-2.jpg', 1, $2, '2025-01-08') RETURNING flyer_id`,
-      [storeId, `checksum-price-2-${Date.now()}`],
+       VALUES ($1, 'price-test-2.jpg', 'https://example.com/flyer-images/price-test-2.jpg', 1, $2, '2025-01-08') RETURNING flyer_id`,
+      [storeId, `${Date.now().toString(16)}2`.padEnd(64, '0')],
     );
     flyerId2 = flyerRes2.rows[0].flyer_id; // This was a duplicate, fixed.
 
     const flyerRes3 = await pool.query(
       `INSERT INTO public.flyers (store_id, file_name, image_url, item_count, checksum, valid_from) 
-       VALUES ($1, 'price-test-3.jpg', 'http://test.com/price-3.jpg', 1, $2, '2025-01-15') RETURNING flyer_id`,
-      [storeId, `checksum-price-3-${Date.now()}`],
+       VALUES ($1, 'price-test-3.jpg', 'https://example.com/flyer-images/price-test-3.jpg', 1, $2, '2025-01-15') RETURNING flyer_id`,
+      [storeId, `${Date.now().toString(16)}3`.padEnd(64, '0')],
     );
     flyerId3 = flyerRes3.rows[0].flyer_id;
 

src/tests/integration/public.routes.integration.test.ts

@@ -78,8 +78,8 @@ describe('Public API Routes Integration Tests', () => {
     testStoreId = storeRes.rows[0].store_id;
     const flyerRes = await pool.query(
       `INSERT INTO public.flyers (store_id, file_name, image_url, item_count, checksum) 
-       VALUES ($1, 'public-routes-test.jpg', 'http://test.com/public-routes.jpg', 1, $2) RETURNING *`,
-      [testStoreId, `checksum-public-routes-${Date.now()}`],
+       VALUES ($1, 'public-routes-test.jpg', 'https://example.com/flyer-images/public-routes-test.jpg', 1, $2) RETURNING *`,
+      [testStoreId, `${Date.now().toString(16)}`.padEnd(64, '0')],
     );
     testFlyer = flyerRes.rows[0];
 

src/tests/integration/recipe.integration.test.ts

@@ -1,5 +1,5 @@
 // src/tests/integration/recipe.integration.test.ts
-import { describe, it, expect, beforeAll, afterAll } from 'vitest';
+import { describe, it, expect, beforeAll, afterAll, vi } from 'vitest';
 import supertest from 'supertest';
 import app from '../../../server';
 import { createAndLoginUser } from '../utils/testHelpers';
@@ -7,6 +7,8 @@ import { cleanupDb } from '../utils/cleanup';
 import type { UserProfile, Recipe, RecipeComment } from '../../types';
 import { getPool } from '../../services/db/connection.db';
 
+import { aiService } from '../../services/aiService.server';
+
 /**
  * @vitest-environment node
  */
@@ -31,6 +33,9 @@ describe('Recipe API Routes Integration Tests', () => {
     authToken = token;
     createdUserIds.push(user.user.user_id);
 
+    // Mock the AI service method using spyOn to preserve other exports like DuplicateFlyerError
+    vi.spyOn(aiService, 'generateRecipeSuggestion').mockResolvedValue('Default Mock Suggestion');
+
     // Create a recipe owned by the test user
     const recipeRes = await getPool().query(
       `INSERT INTO public.recipes (name, instructions, user_id, status, description) 
@@ -124,4 +129,24 @@ describe('Recipe API Routes Integration Tests', () => {
   it.todo('should prevent a user from deleting another user\'s recipe');
   it.todo('should allow an authenticated user to post a comment on a recipe');
   it.todo('should allow an authenticated user to fork a recipe');
+
+  describe('POST /api/recipes/suggest', () => {
+    it('should return a recipe suggestion based on ingredients', async () => {
+      const ingredients = ['chicken', 'rice', 'broccoli'];
+      const mockSuggestion = 'Chicken and Broccoli Stir-fry with Rice';
+      vi.mocked(aiService.generateRecipeSuggestion).mockResolvedValue(mockSuggestion);
+
+      const response = await request
+        .post('/api/recipes/suggest')
+        .set('Authorization', `Bearer ${authToken}`)
+        .send({ ingredients });
+
+      expect(response.status).toBe(200);
+      expect(response.body).toEqual({ suggestion: mockSuggestion });
+      expect(aiService.generateRecipeSuggestion).toHaveBeenCalledWith(
+        ingredients,
+        expect.anything(),
+      );
+    });
+  });
 });

src/tests/utils/mockFactories.ts

@@ -93,6 +93,8 @@ export const createMockUser = (overrides: Partial<User> = {}): User => {
   const defaultUser: User = {
     user_id: userId,
     email: `${userId}@example.com`,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultUser, ...overrides };
@@ -107,7 +109,7 @@ export const createMockUser = (overrides: Partial<User> = {}): User => {
  * @returns A complete and type-safe UserProfile object.
  */
 export const createMockUserProfile = (
-  overrides: Partial<UserProfile & { user: Partial<User> }> = {},
+  overrides: Partial<Omit<UserProfile, 'user'>> & { user?: Partial<User> } = {},
 ): UserProfile => {
   // The user object is the source of truth for user_id and email.
   const user = createMockUser(overrides.user);
@@ -119,10 +121,10 @@ export const createMockUserProfile = (
     avatar_url: null,
     preferences: {},
     address_id: null,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     created_by: null,
     address: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
     user,
   };
 
@@ -143,11 +145,11 @@ export const createMockStore = (overrides: Partial<Store> = {}): Store => {
 
   const defaultStore: Store = {
     store_id: storeId,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     name: 'Mock Store',
     logo_url: null,
     created_by: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultStore, ...overrides };
@@ -167,12 +169,11 @@ export const createMockFlyer = (
   const flyerId = overrides.flyer_id ?? getNextId();
 
   // Ensure the store_id is consistent between the flyer and the nested store object
-  const storeOverrides = overrides.store || {};
-  if (overrides.store_id && !storeOverrides.store_id) {
-    storeOverrides.store_id = overrides.store_id;
-  }
-
-  const store = createMockStore(storeOverrides);
+  const store = createMockStore({
+    ...overrides.store,
+    // Prioritize the top-level store_id if provided
+    store_id: overrides.store_id ?? overrides.store?.store_id,
+  });
 
   // Determine the final file_name to generate dependent properties from.
   const fileName = overrides.file_name ?? `flyer-${flyerId}.jpg`;
@@ -190,8 +191,6 @@ export const createMockFlyer = (
 
   const defaultFlyer: Flyer = {
     flyer_id: flyerId,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     file_name: fileName,
     image_url: `/flyer-images/${fileName}`,
     icon_url: `/flyer-images/icons/icon-${fileName.replace(/\.[^/.]+$/, '.webp')}`,
@@ -203,6 +202,8 @@ export const createMockFlyer = (
     status: 'processed',
     item_count: 50,
     uploaded_by: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
     store,
   };
 
@@ -244,12 +245,12 @@ export const createMockBrand = (overrides: Partial<Brand> = {}): Brand => {
 
   const defaultBrand: Brand = {
     brand_id: brandId,
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     name: `Brand ${brandId}`,
     logo_url: null,
     store_id: null,
     store_name: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultBrand, ...overrides };
@@ -266,6 +267,8 @@ export const createMockCategory = (overrides: Partial<Category> = {}): Category
   const defaultCategory: Category = {
     category_id: categoryId,
     name: `Category ${categoryId}`,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultCategory, ...overrides };
@@ -319,7 +322,6 @@ export const createMockFlyerItem = (
   const defaultItem: FlyerItem = {
     flyer_item_id: flyerItemId,
     flyer_id: flyerId,
-    created_at: new Date().toISOString(),
     item: 'Mock Item',
     price_display: '$1.99',
     price_in_cents: 199,
@@ -327,6 +329,7 @@ export const createMockFlyerItem = (
     quantity: 'each',
     view_count: 0,
     click_count: 0,
+    created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
   };
 
@@ -358,11 +361,11 @@ export const createMockRecipe = (
     rating_count: 50,
     fork_count: 10,
     status: 'public',
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     prep_time_minutes: 15,
     cook_time_minutes: 30,
     servings: 4,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   const {
@@ -412,6 +415,8 @@ export const createMockRecipeIngredient = (
     master_item_id: masterItemId,
     quantity: 1,
     unit: 'cup',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   const { master_item: _, ...itemOverrides } = overrides;
@@ -432,6 +437,7 @@ export const createMockRecipeComment = (overrides: Partial<RecipeComment> = {}):
     content: 'This is a mock comment.',
     status: 'visible',
     created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
     user_full_name: 'Mock User', // This was correct
     user_avatar_url: undefined,
   };
@@ -452,6 +458,8 @@ export const createMockPlannedMeal = (overrides: Partial<PlannedMeal> = {}): Pla
     plan_date: new Date().toISOString().split('T')[0],
     meal_type: 'dinner',
     servings_to_cook: 4,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultMeal, ...overrides };
@@ -476,6 +484,7 @@ export const createMockMenuPlan = (
     start_date: new Date().toISOString().split('T')[0],
     end_date: new Date(Date.now() + 7 * 24 * 60 * 60 * 1000).toISOString().split('T')[0],
     created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   const { planned_meals: mealsOverrides, ...planOverrides } = overrides;
@@ -661,23 +670,22 @@ export const createMockMasterGroceryItem = (
   overrides: Partial<MasterGroceryItem> & { category?: Partial<Category> } = {},
 ): MasterGroceryItem => {
   // Ensure category_id is consistent between the item and the nested category object
-  const categoryOverrides = overrides.category || {};
-  if (overrides.category_id && !categoryOverrides.category_id) {
-    categoryOverrides.category_id = overrides.category_id;
-  }
-
-  const category = createMockCategory(categoryOverrides);
+  const category = createMockCategory({
+    ...overrides.category,
+    // Prioritize the top-level category_id if provided
+    category_id: overrides.category_id ?? overrides.category?.category_id,
+  });
 
   const defaultItem: MasterGroceryItem = {
     master_grocery_item_id: getNextId(),
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     name: 'Mock Master Item',
     category_id: category.category_id,
     category_name: category.name,
     is_allergen: false,
     allergy_info: null,
     created_by: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   const { category: _, ...itemOverrides } = overrides;
@@ -729,9 +737,9 @@ export const createMockShoppingList = (
     shopping_list_id: shoppingListId,
     user_id: `user-${getNextId()}`,
     name: 'My Mock List',
+    items: [],
     created_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
-    items: [],
   };
 
   if (overrides.items) {
@@ -767,15 +775,12 @@ export const createMockShoppingListItem = (
     shopping_list_id: shoppingListId,
     custom_item_name: 'Mock Shopping List Item',
     quantity: 1,
-    is_purchased: false,
+    is_purchased: false, // This was correct
     added_at: new Date().toISOString(),
     updated_at: new Date().toISOString(),
+    master_item_id: masterItemId,
   };
 
-  if (masterItemId) {
-    defaultItem.master_item_id = masterItemId;
-  }
-
   const { master_item: masterItemOverride, ...itemOverrides } = overrides;
   const result = { ...defaultItem, ...itemOverrides };
 
@@ -805,6 +810,8 @@ export const createMockShoppingTripItem = (
     master_item_name: masterItemId ? (overrides.master_item?.name ?? 'Mock Master Item') : null,
     quantity: 1,
     price_paid_cents: 199,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   const { master_item: _, ...itemOverrides } = overrides;
@@ -829,6 +836,7 @@ export const createMockShoppingTrip = (
     completed_at: new Date().toISOString(),
     total_spent_cents: 0,
     items: [],
+    updated_at: new Date().toISOString(),
   };
 
   const { items: itemsOverrides, ...tripOverrides } = overrides;
@@ -864,6 +872,8 @@ export const createMockReceiptItem = (overrides: Partial<ReceiptItem> = {}): Rec
     master_item_id: null,
     product_id: null,
     status: 'unmatched',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultItem, ...overrides };
@@ -888,8 +898,9 @@ export const createMockReceipt = (
     total_amount_cents: null,
     status: 'pending',
     raw_text: null,
-    created_at: new Date().toISOString(),
     processed_at: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   const { items: itemsOverrides, ...receiptOverrides } = overrides;
@@ -916,6 +927,8 @@ export const createMockDietaryRestriction = (
     dietary_restriction_id: 1,
     name: 'Vegetarian',
     type: 'diet',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
     ...overrides,
   };
 };
@@ -955,6 +968,8 @@ export const createMockItemPriceHistory = (
     max_price_in_cents: 399,
     avg_price_in_cents: 299,
     data_points_count: 10,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
   return { ...defaultHistory, ...overrides };
 };
@@ -1008,6 +1023,7 @@ export const createMockRecipeCollection = (
     name: 'My Favorite Recipes',
     description: 'A collection of mock recipes.',
     created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
   return { ...defaultCollection, ...overrides };
 };
@@ -1027,6 +1043,7 @@ export const createMockSharedShoppingList = (
     shared_with_user_id: `user-${getNextId()}`,
     permission_level: 'view',
     created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
   return { ...defaultSharedList, ...overrides };
 };
@@ -1118,6 +1135,7 @@ export const createMockUserAlert = (overrides: Partial<UserAlert> = {}): UserAle
     threshold_value: 499,
     is_active: true,
     created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
   return { ...defaultAlert, ...overrides };
 };
@@ -1140,6 +1158,7 @@ export const createMockUserSubmittedPrice = (
     upvotes: 0,
     downvotes: 0,
     created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
   return { ...defaultPrice, ...overrides };
 };
@@ -1157,6 +1176,7 @@ export const createMockRecipeRating = (overrides: Partial<RecipeRating> = {}): R
     rating: 5,
     comment: 'Great recipe!',
     created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
   return { ...defaultRating, ...overrides };
 };
@@ -1171,6 +1191,8 @@ export const createMockTag = (overrides: Partial<Tag> = {}): Tag => {
   const defaultTag: Tag = {
     tag_id: tagId,
     name: `Tag ${tagId}`,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
   return { ...defaultTag, ...overrides };
 };
@@ -1188,6 +1210,8 @@ export const createMockPantryLocation = (
     pantry_location_id: locationId,
     user_id: `user-${getNextId()}`,
     name: `Location ${locationId}`,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
   return { ...defaultLocation, ...overrides };
 };
@@ -1228,6 +1252,7 @@ export const createMockUserDietaryRestriction = (
   const defaultUserRestriction: UserDietaryRestriction = {
     user_id: userId,
     restriction_id: restrictionId,
+    created_at: new Date().toISOString(),
   };
 
   return { ...defaultUserRestriction, ...overrides };
@@ -1245,12 +1270,14 @@ export const createMockUserAppliance = (
   const userId = overrides.user_id ?? overrides.user?.user_id ?? `user-${getNextId()}`;
   const applianceId = overrides.appliance_id ?? overrides.appliance?.appliance_id ?? getNextId();
 
-  const defaultUserAppliance: UserAppliance = {
+  const defaultUserAppliance = {
     user_id: userId,
     appliance_id: applianceId,
+    created_at: new Date().toISOString(),
   };
 
-  return { ...defaultUserAppliance, ...overrides };
+  // The 'as UserAppliance' cast is necessary because TypeScript can't guarantee that the spread of a Partial<T> results in a complete T.
+  return { ...defaultUserAppliance, ...overrides } as UserAppliance;
 };
 
 /**
@@ -1266,13 +1293,13 @@ export const createMockAddress = (overrides: Partial<Address> = {}): Address =>
     province_state: 'BC',
     postal_code: 'V8T 1A1',
     country: 'CA',
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     // Optional fields
     address_line_2: null,
     latitude: null,
     longitude: null,
     location: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultAddress, ...overrides };
@@ -1309,8 +1336,6 @@ export const createMockUserWithPasswordHash = (
  */
 export const createMockProfile = (overrides: Partial<Profile> = {}): Profile => {
   const defaultProfile: Profile = {
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     full_name: 'Mock Profile User',
     avatar_url: null,
     address_id: null,
@@ -1319,6 +1344,8 @@ export const createMockProfile = (overrides: Partial<Profile> = {}): Profile =>
     preferences: {},
     created_by: null,
     updated_by: null,
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultProfile, ...overrides };
@@ -1376,14 +1403,14 @@ export const createMockUnmatchedFlyerItem = (
   const defaultItem: UnmatchedFlyerItem = {
     unmatched_flyer_item_id: getNextId(),
     status: 'pending',
-    created_at: new Date().toISOString(),
-    updated_at: new Date().toISOString(),
     reviewed_at: null,
     flyer_item_id: getNextId(),
     flyer_item_name: 'Mystery Product',
     price_display: '$?.??',
     flyer_id: getNextId(),
     store_name: 'Random Store',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
   };
 
   return { ...defaultItem, ...overrides };
@@ -1400,10 +1427,10 @@ export const createMockAdminUserView = (overrides: Partial<AdminUserView> = {}):
   const defaultUserView: AdminUserView = {
     user_id: userId,
     email: `${userId}@example.com`,
-    created_at: new Date().toISOString(),
     role: 'user',
     full_name: 'Mock User',
     avatar_url: null,
+    created_at: new Date().toISOString(),
   };
 
   return { ...defaultUserView, ...overrides };
@@ -1450,6 +1477,8 @@ export const createMockAppliance = (overrides: Partial<Appliance> = {}): Applian
   return {
     appliance_id: 1,
     name: 'Oven',
+    created_at: new Date().toISOString(),
+    updated_at: new Date().toISOString(),
     ...overrides,
   };
 };
@@ -1482,7 +1511,7 @@ export const createMockAddressPayload = (overrides: Partial<Address> = {}): Part
   ...overrides,
 });
 
-export const createMockSearchQueryPayload = (overrides: Partial<Omit<SearchQuery, 'search_query_id' | 'id' | 'created_at' | 'user_id'>> = {}): Omit<SearchQuery, 'search_query_id' | 'id' | 'created_at' | 'user_id'> => ({
+export const createMockSearchQueryPayload = (overrides: Partial<Omit<SearchQuery, 'search_query_id' | 'created_at' | 'updated_at' | 'user_id'>> = {}): Omit<SearchQuery, 'search_query_id' | 'created_at' | 'updated_at' | 'user_id'> => ({
   query_text: 'mock search',
   result_count: 5,
   was_successful: true,

src/tests/utils/renderWithProviders.tsx

@@ -0,0 +1,31 @@
+// src/tests/utils/renderWithProviders.tsx
+import React, { ReactElement } from 'react';
+import { render, RenderOptions } from '@testing-library/react';
+import { AppProviders } from '../../providers/AppProviders';
+import { MemoryRouter } from 'react-router-dom';
+
+interface ExtendedRenderOptions extends Omit<RenderOptions, 'wrapper'> {
+  initialEntries?: string[];
+}
+
+/**
+ * A custom render function that wraps the component with all application providers.
+ * This is useful for testing components that rely on context values (Auth, Modal, etc.).
+ *
+ * @param ui The component to render
+ * @param options Additional render options
+ * @returns The result of the render function
+ */
+export const renderWithProviders = (
+  ui: ReactElement,
+  options?: ExtendedRenderOptions,
+) => {
+  const { initialEntries, ...renderOptions } = options || {};
+  // console.log('[renderWithProviders] Wrapping component with AppProviders context.');
+  const Wrapper = ({ children }: { children: React.ReactNode }) => (
+    <MemoryRouter initialEntries={initialEntries}>
+      <AppProviders>{children}</AppProviders>
+    </MemoryRouter>
+  );
+  return render(ui, { wrapper: Wrapper, ...renderOptions });
+};

src/types.ts

@@ -1,31 +1,31 @@
 // src/types.ts
 export interface Store {
-  store_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly store_id: number;
   name: string;
   logo_url?: string | null;
-  created_by?: string | null;
+  readonly created_by?: string | null;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export type FlyerStatus = 'processed' | 'needs_review' | 'archived';
 
 export interface Flyer {
-  flyer_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly flyer_id: number;
   file_name: string;
   image_url: string;
   icon_url?: string | null; // URL for the 64x64 icon version of the flyer
-  checksum?: string;
-  store_id?: number;
+  readonly checksum?: string;
+  readonly store_id?: number;
   valid_from?: string | null;
   valid_to?: string | null;
   store_address?: string | null;
   status: FlyerStatus;
   item_count: number;
-  uploaded_by?: string | null; // UUID of the user who uploaded it, can be null for anonymous uploads
+  readonly uploaded_by?: string | null; // UUID of the user who uploaded it, can be null for anonymous uploads
   store?: Store;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 /**
@@ -67,64 +67,64 @@ export interface UnitPrice {
 }
 
 export interface FlyerItem {
-  flyer_item_id: number;
-  flyer_id: number;
-  created_at: string;
+  readonly flyer_item_id: number;
+  readonly flyer_id: number;
   item: string;
   price_display: string;
   price_in_cents?: number | null;
   quantity?: string;
   quantity_num?: number | null;
-  master_item_id?: number;
+  master_item_id?: number; // Can be updated by admin correction
   master_item_name?: string | null;
-  category_id?: number | null;
+  category_id?: number | null; // Can be updated by admin correction
   category_name?: string | null;
   unit_price?: UnitPrice | null;
-  product_id?: number | null;
-  view_count: number;
-  click_count: number;
-  updated_at: string;
+  product_id?: number | null; // Can be updated by admin correction
+  readonly view_count: number;
+  readonly click_count: number;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface MasterGroceryItem {
-  master_grocery_item_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly master_grocery_item_id: number;
   name: string;
-  category_id?: number | null;
+  category_id?: number | null; // Can be updated by admin
   category_name?: string | null;
   is_allergen?: boolean;
   allergy_info?: unknown | null; // JSONB
-  created_by?: string | null;
+  readonly created_by?: string | null;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface Category {
-  category_id: number;
+  readonly category_id: number;
   name: string;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface Brand {
-  brand_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly brand_id: number;
   name: string;
   logo_url?: string | null;
-  store_id?: number | null;
+  readonly store_id?: number | null;
   store_name?: string | null;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface Product {
-  product_id: number;
-  created_at: string;
-  updated_at: string;
-  master_item_id: number;
-  brand_id?: number | null;
+  readonly product_id: number;
+  readonly master_item_id: number;
+  readonly brand_id?: number | null;
   name: string;
   description?: string | null;
   size?: string | null;
   upc_code?: string | null;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface DealItem {
@@ -139,8 +139,10 @@ export interface DealItem {
 
 // User-specific types
 export interface User {
-  user_id: string; // UUID
+  readonly user_id: string; // UUID
   email: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 /**
@@ -149,27 +151,25 @@ export interface User {
  */
 export interface UserWithPasswordHash extends User {
   password_hash: string | null;
-  failed_login_attempts: number;
-  last_failed_login: string | null; // TIMESTAMPTZ
-  last_login_at?: string | null; // TIMESTAMPTZ
-  last_login_ip?: string | null;
-  created_at: string;
-  updated_at: string;
+  readonly failed_login_attempts: number;
+  readonly last_failed_login: string | null; // TIMESTAMPTZ
+  readonly last_login_at?: string | null; // TIMESTAMPTZ
+  readonly last_login_ip?: string | null;
 }
 export interface Profile {
-  created_at: string;
-  updated_at: string;
   full_name?: string | null;
   avatar_url?: string | null;
-  address_id?: number | null;
-  points: number;
-  role: 'admin' | 'user';
+  address_id?: number | null; // Can be updated
+  readonly points: number;
+  readonly role: 'admin' | 'user';
   preferences?: {
     darkMode?: boolean;
     unitSystem?: 'metric' | 'imperial';
   } | null;
-  created_by?: string | null;
-  updated_by?: string | null;
+  readonly created_by?: string | null;
+  readonly updated_by?: string | null;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 /**
@@ -183,16 +183,16 @@ export type UserProfile = Profile & {
 };
 
 export interface SuggestedCorrection {
-  suggested_correction_id: number;
-  flyer_item_id: number;
-  user_id: string;
+  readonly suggested_correction_id: number;
+  readonly flyer_item_id: number;
+  readonly user_id: string;
   correction_type: string;
   suggested_value: string;
   status: 'pending' | 'approved' | 'rejected';
-  created_at: string;
-  updated_at: string;
-  reviewed_at?: string | null;
+  readonly reviewed_at?: string | null;
   reviewed_notes?: string | null;
+  readonly created_at: string;
+  readonly updated_at: string;
   // Joined data
   user_email?: string;
   flyer_item_name?: string;
@@ -212,44 +212,44 @@ export interface UserDataExport {
 }
 
 export interface UserAlert {
-  user_alert_id: number;
-  user_watched_item_id: number;
+  readonly user_alert_id: number;
+  readonly user_watched_item_id: number;
   alert_type: 'PRICE_BELOW' | 'PERCENT_OFF_AVERAGE';
   threshold_value: number;
   is_active: boolean;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface Notification {
-  notification_id: number;
-  user_id: string; // UUID
+  readonly notification_id: number;
+  readonly user_id: string; // UUID
   content: string;
   link_url?: string | null;
   is_read: boolean;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface ShoppingList {
-  shopping_list_id: number;
-  user_id: string; // UUID
+  readonly shopping_list_id: number;
+  readonly user_id: string; // UUID
   name: string;
-  created_at: string;
-  updated_at: string;
   items: ShoppingListItem[]; // Nested items
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface ShoppingListItem {
-  shopping_list_item_id: number;
-  shopping_list_id: number;
-  master_item_id?: number | null;
+  readonly shopping_list_item_id: number;
+  readonly shopping_list_id: number;
+  readonly master_item_id?: number | null;
   custom_item_name?: string | null;
   quantity: number;
   is_purchased: boolean;
   notes?: string | null;
-  added_at: string;
-  updated_at: string;
+  readonly added_at: string;
+  readonly updated_at: string;
   // Joined data for display
   master_item?: {
     name: string;
@@ -257,29 +257,29 @@ export interface ShoppingListItem {
 }
 
 export interface UserSubmittedPrice {
-  user_submitted_price_id: number;
-  user_id: string; // UUID
-  master_item_id: number;
-  store_id: number;
+  readonly user_submitted_price_id: number;
+  readonly user_id: string; // UUID
+  readonly master_item_id: number;
+  readonly store_id: number;
   price_in_cents: number;
   photo_url?: string | null;
-  upvotes: number;
-  downvotes: number;
-  created_at: string;
-  updated_at: string;
+  readonly upvotes: number;
+  readonly downvotes: number;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface ItemPriceHistory {
-  item_price_history_id: number;
-  master_item_id: number;
+  readonly item_price_history_id: number;
+  readonly master_item_id: number;
   summary_date: string; // DATE
-  store_location_id?: number | null;
+  readonly store_location_id?: number | null;
   min_price_in_cents?: number | null;
   max_price_in_cents?: number | null;
   avg_price_in_cents?: number | null;
   data_points_count: number;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 /**
@@ -293,17 +293,17 @@ export interface HistoricalPriceDataPoint {
 }
 
 export interface MasterItemAlias {
-  master_item_alias_id: number;
-  master_item_id: number;
+  readonly master_item_alias_id: number;
+  readonly master_item_id: number;
   alias: string;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface Recipe {
-  recipe_id: number;
-  user_id?: string | null; // UUID
-  original_recipe_id?: number | null;
+  readonly recipe_id: number;
+  readonly user_id?: string | null; // UUID
+  readonly original_recipe_id?: number | null;
   name: string;
   description?: string | null;
   instructions?: string | null;
@@ -315,216 +315,207 @@ export interface Recipe {
   protein_grams?: number | null;
   fat_grams?: number | null;
   carb_grams?: number | null;
-  avg_rating: number;
+  readonly avg_rating: number;
   status: 'private' | 'pending_review' | 'public' | 'rejected';
-  rating_count: number;
-  fork_count: number;
-  created_at: string;
-  updated_at: string;
+  readonly rating_count: number;
+  readonly fork_count: number;
   comments?: RecipeComment[];
   ingredients?: RecipeIngredient[];
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface RecipeIngredient {
-  recipe_ingredient_id: number;
-  recipe_id: number;
-  master_item_id: number;
+  readonly recipe_ingredient_id: number;
+  readonly recipe_id: number;
+  readonly master_item_id: number;
   quantity: number;
   unit: string;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface RecipeIngredientSubstitution {
-  recipe_ingredient_substitution_id: number;
-  recipe_ingredient_id: number;
-  substitute_master_item_id: number;
+  readonly recipe_ingredient_substitution_id: number;
+  readonly recipe_ingredient_id: number;
+  readonly substitute_master_item_id: number;
   notes?: string | null;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface Tag {
-  tag_id: number;
+  readonly tag_id: number;
   name: string;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface RecipeTag {
   recipe_id: number;
   tag_id: number;
-  created_at: string;
-  updated_at: string;
 }
 
 export interface RecipeRating {
-  recipe_rating_id: number;
-  recipe_id: number;
-  user_id: string; // UUID
+  readonly recipe_rating_id: number;
+  readonly recipe_id: number;
+  readonly user_id: string; // UUID
   rating: number;
   comment?: string | null;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface RecipeComment {
-  recipe_comment_id: number;
-  recipe_id: number;
-  user_id: string; // UUID
-  parent_comment_id?: number | null;
+  readonly recipe_comment_id: number;
+  readonly recipe_id: number;
+  readonly user_id: string; // UUID
+  readonly parent_comment_id?: number | null;
   content: string;
   status: 'visible' | 'hidden' | 'reported';
-  created_at: string;
-  updated_at?: string | null;
+  readonly created_at: string;
+  readonly updated_at: string;
   user_full_name?: string; // Joined data
   user_avatar_url?: string; // Joined data
 }
 
 export interface MenuPlan {
-  menu_plan_id: number;
-  user_id: string; // UUID
+  readonly menu_plan_id: number;
+  readonly user_id: string; // UUID
   name: string;
   start_date: string; // DATE
   end_date: string; // DATE
-  created_at: string;
-  updated_at: string;
   planned_meals?: PlannedMeal[];
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface SharedMenuPlan {
-  shared_menu_plan_id: number;
-  menu_plan_id: number;
-  shared_by_user_id: string; // UUID
-  shared_with_user_id: string; // UUID
+  readonly shared_menu_plan_id: number;
+  readonly menu_plan_id: number;
+  readonly shared_by_user_id: string; // UUID
+  readonly shared_with_user_id: string; // UUID
   permission_level: 'view' | 'edit';
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface PlannedMeal {
-  planned_meal_id: number;
-  menu_plan_id: number;
-  recipe_id: number;
+  readonly planned_meal_id: number;
+  readonly menu_plan_id: number;
+  readonly recipe_id: number;
   plan_date: string; // DATE
   meal_type: string;
   servings_to_cook?: number | null;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface PantryItem {
-  pantry_item_id: number;
-  user_id: string; // UUID
-  master_item_id: number;
+  readonly pantry_item_id: number;
+  readonly user_id: string; // UUID
+  readonly master_item_id: number;
   quantity: number;
   unit?: string | null;
   best_before_date?: string | null; // DATE
   pantry_location_id?: number | null;
-  notification_sent_at?: string | null; // TIMESTAMPTZ
-  updated_at: string;
+  readonly notification_sent_at?: string | null; // TIMESTAMPTZ
+  readonly updated_at: string;
 }
 
 export interface UserItemAlias {
-  user_item_alias_id: number;
-  user_id: string; // UUID
-  master_item_id: number;
+  readonly user_item_alias_id: number;
+  readonly user_id: string; // UUID
+  readonly master_item_id: number;
   alias: string;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface FavoriteRecipe {
-  user_id: string; // UUID
-  recipe_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly user_id: string; // UUID
+  readonly recipe_id: number;
+  readonly created_at: string;
 }
 
 export interface FavoriteStore {
-  user_id: string; // UUID
-  store_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly user_id: string; // UUID
+  readonly store_id: number;
+  readonly created_at: string;
 }
 
 export interface RecipeCollection {
-  recipe_collection_id: number;
-  user_id: string; // UUID
+  readonly recipe_collection_id: number;
+  readonly user_id: string; // UUID
   name: string;
   description?: string | null;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface RecipeCollectionItem {
-  collection_id: number;
-  recipe_id: number;
-  added_at: string;
-  updated_at: string;
+  readonly collection_id: number;
+  readonly recipe_id: number;
+  readonly added_at: string;
 }
 
 export interface SharedShoppingList {
-  shared_shopping_list_id: number;
-  shopping_list_id: number;
-  shared_by_user_id: string; // UUID
-  shared_with_user_id: string; // UUID
+  readonly shared_shopping_list_id: number;
+  readonly shopping_list_id: number;
+  readonly shared_by_user_id: string; // UUID
+  readonly shared_with_user_id: string; // UUID
   permission_level: 'view' | 'edit';
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface SharedRecipeCollection {
-  shared_collection_id: number;
-  recipe_collection_id: number;
-  shared_by_user_id: string; // UUID
-  shared_with_user_id: string; // UUID
+  readonly shared_collection_id: number;
+  readonly recipe_collection_id: number;
+  readonly shared_by_user_id: string; // UUID
+  readonly shared_with_user_id: string; // UUID
   permission_level: 'view' | 'edit';
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface DietaryRestriction {
-  dietary_restriction_id: number;
+  readonly dietary_restriction_id: number;
   name: string;
   type: 'diet' | 'allergy';
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface UserDietaryRestriction {
-  user_id: string; // UUID
-  restriction_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly user_id: string; // UUID
+  readonly restriction_id: number;
+  readonly created_at: string;
 }
 
 export interface Appliance {
-  appliance_id: number;
+  readonly appliance_id: number;
   name: string;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface UserAppliance {
-  user_id: string; // UUID
-  appliance_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly user_id: string; // UUID
+  readonly appliance_id: number;
+  readonly created_at: string;
 }
 
 export interface RecipeAppliance {
-  recipe_id: number;
-  appliance_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly recipe_id: number;
+  readonly appliance_id: number;
+  readonly created_at: string;
 }
 
 export interface UserFollow {
-  follower_id: string; // UUID
-  following_id: string; // UUID
-  created_at: string;
-  updated_at: string;
+  readonly follower_id: string; // UUID
+  readonly following_id: string; // UUID
+  readonly created_at: string;
 }
 /**
  * The list of possible actions for an activity log.
@@ -543,13 +534,13 @@ export type ActivityLogAction =
  * Base interface for all log items, containing common properties.
  */
 interface ActivityLogItemBase {
-  activity_log_id: number;
-  user_id: string | null;
+  readonly activity_log_id: number;
+  readonly user_id: string | null;
   action: string;
   display_text: string;
-  created_at: string;
-  updated_at: string;
   icon?: string | null;
+  readonly created_at: string;
+  readonly updated_at: string;
   // Joined data for display in feeds
   user_full_name?: string;
   user_avatar_url?: string;
@@ -608,77 +599,77 @@ export type ActivityLogItem =
   | ListSharedLog;
 
 export interface PantryLocation {
-  pantry_location_id: number;
-  user_id: string; // UUID
+  readonly pantry_location_id: number;
+  readonly user_id: string; // UUID
   name: string;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface SearchQuery {
-  search_query_id: number;
-  user_id?: string | null; // UUID
+  readonly search_query_id: number;
+  readonly user_id?: string | null; // UUID
   query_text: string;
   result_count?: number | null;
   was_successful?: boolean | null;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface ShoppingTripItem {
-  shopping_trip_item_id: number;
-  shopping_trip_id: number;
-  master_item_id?: number | null;
+  readonly shopping_trip_item_id: number;
+  readonly shopping_trip_id: number;
+  readonly master_item_id?: number | null;
   custom_item_name?: string | null;
   quantity: number;
   price_paid_cents?: number | null;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
   // Joined data for display
   master_item_name?: string | null;
 }
 
 export interface ShoppingTrip {
-  shopping_trip_id: number;
-  user_id: string; // UUID
-  shopping_list_id?: number | null;
-  completed_at: string;
+  readonly shopping_trip_id: number;
+  readonly user_id: string; // UUID
+  readonly shopping_list_id?: number | null;
+  readonly completed_at: string;
   total_spent_cents?: number | null;
-  updated_at: string;
   items: ShoppingTripItem[]; // Nested items
+  readonly updated_at: string;
 }
 
 export interface Receipt {
-  receipt_id: number;
-  user_id: string; // UUID
+  readonly receipt_id: number;
+  readonly user_id: string; // UUID
   store_id?: number | null;
   receipt_image_url: string;
   transaction_date?: string | null;
   total_amount_cents?: number | null;
   status: 'pending' | 'processing' | 'completed' | 'failed';
   raw_text?: string | null;
-  created_at: string;
-  processed_at?: string | null;
-  updated_at: string;
+  readonly processed_at?: string | null;
   items?: ReceiptItem[];
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface ReceiptItem {
-  receipt_item_id: number;
-  receipt_id: number;
+  readonly receipt_item_id: number;
+  readonly receipt_id: number;
   raw_item_description: string;
   quantity: number;
   price_paid_cents: number;
-  master_item_id?: number | null;
-  product_id?: number | null;
+  master_item_id?: number | null; // Can be updated by admin correction
+  product_id?: number | null; // Can be updated by admin correction
   status: 'unmatched' | 'matched' | 'needs_review' | 'ignored';
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface ReceiptDeal {
-  receipt_item_id: number;
-  master_item_id: number;
+  readonly receipt_item_id: number;
+  readonly master_item_id: number;
   item_name: string;
   price_paid_cents: number;
   current_best_price_in_cents: number;
@@ -697,15 +688,15 @@ export interface GeoJSONPoint {
 }
 
 export interface StoreLocation {
-  store_location_id: number;
-  store_id?: number | null;
-  address_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly store_location_id: number;
+  readonly store_id?: number | null;
+  readonly address_id: number;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface Address {
-  address_id: number;
+  readonly address_id: number;
   address_line_1: string;
   address_line_2?: string | null;
   city: string;
@@ -714,16 +705,16 @@ export interface Address {
   country: string;
   latitude?: number | null;
   longitude?: number | null;
-  location?: GeoJSONPoint | null;
-  created_at: string;
-  updated_at: string;
+  readonly location?: GeoJSONPoint | null;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface FlyerLocation {
-  flyer_id: number;
-  store_location_id: number;
-  created_at: string;
-  updated_at: string;
+  readonly flyer_id: number;
+  readonly store_location_id: number;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export enum AnalysisType {
@@ -933,30 +924,30 @@ export interface MenuPlanShoppingListItem {
  * Returned by `getUnmatchedFlyerItems`.
  */
 export interface UnmatchedFlyerItem {
-  unmatched_flyer_item_id: number;
+  readonly unmatched_flyer_item_id: number;
   status: 'pending' | 'resolved' | 'ignored'; // 'resolved' is used instead of 'reviewed' from the DB for clarity
-  created_at: string; // Date string
-  updated_at: string;
-  reviewed_at?: string | null;
-  flyer_item_id: number;
+  readonly reviewed_at?: string | null;
+  readonly flyer_item_id: number;
   flyer_item_name: string;
   price_display: string;
   flyer_id: number;
   store_name: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 /**
  * Represents a user-defined budget for tracking grocery spending.
  */
 export interface Budget {
-  budget_id: number;
-  user_id: string; // UUID
+  readonly budget_id: number;
+  readonly user_id: string; // UUID
   name: string;
   amount_cents: number;
   period: 'weekly' | 'monthly';
   start_date: string; // DATE
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 /**
@@ -973,21 +964,21 @@ export interface SpendingByCategory {
  * Represents a single defined achievement in the system.
  */
 export interface Achievement {
-  achievement_id: number;
+  readonly achievement_id: number;
   name: string;
   description: string;
   icon?: string | null;
   points_value: number;
-  created_at: string;
+  readonly created_at: string;
 }
 
 /**
  * Represents an achievement that has been awarded to a user.
  */
 export interface UserAchievement {
-  user_id: string; // UUID
-  achievement_id: number;
-  achieved_at: string; // TIMESTAMPTZ
+  readonly user_id: string; // UUID
+  readonly achievement_id: number;
+  readonly achieved_at: string; // TIMESTAMPTZ
 }
 
 /**
@@ -995,11 +986,11 @@ export interface UserAchievement {
  * Returned by the `getLeaderboard` database function.
  */
 export interface LeaderboardUser {
-  user_id: string;
+  readonly user_id: string;
   full_name: string | null;
   avatar_url: string | null;
   points: number;
-  rank: string; // RANK() returns a bigint, which the pg driver returns as a string.
+  readonly rank: string; // RANK() returns a bigint, which the pg driver returns as a string.
 }
 
 /**
@@ -1007,12 +998,12 @@ export interface LeaderboardUser {
  * This is a public-facing type and does not include sensitive fields.
  */
 export interface AdminUserView {
-  user_id: string;
+  readonly user_id: string;
   email: string;
-  created_at: string;
   role: 'admin' | 'user';
   full_name: string | null;
   avatar_url: string | null;
+  readonly created_at: string;
 }
 
 export interface PriceHistoryData {
@@ -1022,21 +1013,21 @@ export interface PriceHistoryData {
 }
 
 export interface UserReaction {
-  reaction_id: number;
-  user_id: string; // UUID
-  entity_type: string;
-  entity_id: string;
+  readonly reaction_id: number;
+  readonly user_id: string; // UUID
+  readonly entity_type: string;
+  readonly entity_id: string;
   reaction_type: string;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }
 
 export interface UnitConversion {
-  unit_conversion_id: number;
-  master_item_id: number;
+  readonly unit_conversion_id: number;
+  readonly master_item_id: number;
   from_unit: string;
   to_unit: string;
   factor: number;
-  created_at: string;
-  updated_at: string;
+  readonly created_at: string;
+  readonly updated_at: string;
 }