ci: Bump version to 0.2.32 [skip ci]

package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "flyer-crawler",
-  "version": "0.2.30",
+  "version": "0.2.32",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "flyer-crawler",
-      "version": "0.2.30",
+      "version": "0.2.32",
       "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.2.30",
+  "version": "0.2.32",
   "type": "module",
   "scripts": {
     "dev": "concurrently \"npm:start:dev\" \"vite\"",

src/routes/system.routes.test.ts

@@ -5,45 +5,6 @@ import { exec, type ExecException, type ExecOptions } from 'child_process';
 import { geocodingService } from '../services/geocodingService.server';
 import { createTestApp } from '../tests/utils/createTestApp';
 
-// FIX: Mock util.promisify to correctly handle child_process.exec's (err, stdout, stderr) signature.
-// This is required because the standard util.promisify relies on internal symbols on the real exec function,
-// which are missing on our Vitest mock. Without this, promisify(mockExec) drops the stdout/stderr arguments.
-vi.mock('util', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('util')>();
-  return {
-    ...actual,
-    promisify: (fn: Function) => {
-      return (...args: any[]) => {
-        return new Promise((resolve, reject) => {
-          fn(...args, (err: Error | null, stdout: string, stderr: string) => {
-            if (err) {
-              // Attach stdout/stderr to the error object to mimic child_process.exec behavior
-              Object.assign(err, { stdout, stderr });
-              reject(err);
-            } else {
-              resolve({ stdout, stderr });
-            }
-          });
-        });
-      };
-    },
-  };
-});
-
-// FIX: Use the simple factory pattern for child_process to avoid default export issues
-vi.mock('child_process', () => {
-  const mockExec = vi.fn((command, callback) => {
-    if (typeof callback === 'function') {
-      callback(null, 'PM2 OK', '');
-    }
-    return { unref: () => {} };
-  });
-
-  return {
-    exec: mockExec,
-  };
-});
-
 // 2. Mock Geocoding
 vi.mock('../services/geocodingService.server', () => ({
   geocodingService: {

src/services/authService.test.ts

@@ -1,15 +1,16 @@
 import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { UniqueConstraintError } from './db/errors.db';
 import type { UserProfile } from '../types';
+import type * as jsonwebtoken from 'jsonwebtoken';
 
 describe('AuthService', () => {
   let authService: typeof import('./authService').authService;
   let bcrypt: typeof import('bcrypt');
-  let jwt: typeof import('jsonwebtoken');
+  let jwt: typeof jsonwebtoken & { default: typeof jsonwebtoken };
   let userRepo: typeof import('./db/index.db').userRepo;
   let adminRepo: typeof import('./db/index.db').adminRepo;
   let logger: typeof import('./logger.server').logger;
   let sendPasswordResetEmail: typeof import('./emailService.server').sendPasswordResetEmail;
+  let UniqueConstraintError: typeof import('./db/errors.db').UniqueConstraintError;
 
   const reqLog = {}; // Mock request logger object
   const mockUser = {
@@ -31,15 +32,8 @@ describe('AuthService', () => {
     process.env.FRONTEND_URL = 'http://localhost:3000';
 
     // Mock all dependencies before dynamically importing the service
+    // Core modules like bcrypt, jsonwebtoken, and crypto are now mocked globally in tests-setup-unit.ts
     vi.mock('bcrypt');
-    vi.mock('jsonwebtoken');
-    vi.mock('crypto', () => ({
-      default: {
-        randomBytes: vi.fn().mockReturnValue({
-          toString: vi.fn().mockReturnValue('mocked-random-string'),
-        }),
-      },
-    }));
     vi.mock('./db/index.db', () => ({
       userRepo: {
         createUser: vi.fn(),
@@ -69,12 +63,13 @@ describe('AuthService', () => {
     // Dynamically import modules to get the mocked versions and the service instance
     authService = (await import('./authService')).authService;
     bcrypt = await import('bcrypt');
-    jwt = await import('jsonwebtoken');
+    jwt = (await import('jsonwebtoken')) as typeof jwt;
     const dbModule = await import('./db/index.db');
     userRepo = dbModule.userRepo;
     adminRepo = dbModule.adminRepo;
     logger = (await import('./logger.server')).logger;
     sendPasswordResetEmail = (await import('./emailService.server')).sendPasswordResetEmail;
+    UniqueConstraintError = (await import('./db/errors.db')).UniqueConstraintError;
   });
 
   describe('registerUser', () => {
@@ -137,7 +132,10 @@ describe('AuthService', () => {
       // Mock registerUser logic (since we can't easily spy on the same class instance method without prototype spying, we rely on the underlying calls)
       vi.mocked(bcrypt.hash).mockImplementation(async () => 'hashed-password');
       vi.mocked(userRepo.createUser).mockResolvedValue(mockUserProfile);
-      vi.mocked(jwt.sign).mockImplementation(() => 'access-token' as any);
+      // 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.
+      // We must mock `jwt.default.sign` to affect the code under test.
+      vi.mocked(jwt.default.sign).mockImplementation(() => 'access-token');
 
       const result = await authService.registerAndLoginUser(
         'test@example.com',
@@ -162,11 +160,14 @@ describe('AuthService', () => {
 
   describe('generateAuthTokens', () => {
     it('should generate access and refresh tokens', () => {
-      vi.mocked(jwt.sign).mockImplementation(() => 'access-token' as any);
+      // 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.
+      // We must mock `jwt.default.sign` to affect the code under test.
+      vi.mocked(jwt.default.sign).mockImplementation(() => 'access-token');
 
       const result = authService.generateAuthTokens(mockUserProfile);
 
-      expect(jwt.sign).toHaveBeenCalledWith(
+      expect(vi.mocked(jwt.default.sign)).toHaveBeenCalledWith(
         {
           user_id: 'user-123',
           email: 'test@example.com',
@@ -319,7 +320,10 @@ describe('AuthService', () => {
     it('should return new access token if user found', async () => {
       vi.mocked(userRepo.findUserByRefreshToken).mockResolvedValue({ user_id: 'user-123' } as any);
       vi.mocked(userRepo.findUserProfileById).mockResolvedValue(mockUserProfile);
-      vi.mocked(jwt.sign).mockImplementation(() => 'new-access-token' as any);
+      // 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.
+      // We must mock `jwt.default.sign` to affect the code under test.
+      vi.mocked(jwt.default.sign).mockImplementation(() => 'new-access-token');
 
       const result = await authService.refreshAccessToken('valid-token', reqLog);
 

src/services/flyerProcessingService.server.test.ts

@@ -409,24 +409,18 @@ describe('FlyerProcessingService', () => {
       mockFileHandler.prepareImageInputs.mockRejectedValue(fileTypeError);
       const { logger } = await import('./logger.server');
 
+      const reportErrorSpy = vi.spyOn(service as any, '_reportErrorAndThrow');
+
       await expect(service.processJob(job)).rejects.toThrow(UnsupportedFileTypeError);
-      expect(job.updateProgress).toHaveBeenCalledWith({
-        errorCode: 'UNSUPPORTED_FILE_TYPE',
-        message: 'Unsupported file type: .txt. Supported types are PDF, JPG, PNG, WEBP, HEIC, HEIF, GIF, TIFF, SVG, BMP.',
-        stages: [
-          { name: 'Preparing Inputs', status: 'failed', critical: true, detail: 'Unsupported file type: .txt. Supported types are PDF, JPG, PNG, WEBP, HEIC, HEIF, GIF, TIFF, SVG, BMP.' },
-          { name: 'Extracting Data with AI', status: 'skipped', critical: true, detail: 'Communicating with AI model...' },
-          { name: 'Transforming AI Data', status: 'skipped', critical: true },
-          { name: 'Saving to Database', status: 'skipped', critical: true },
-        ],
-      });
+
+      expect(reportErrorSpy).toHaveBeenCalledWith(fileTypeError, job, expect.any(Object), expect.any(Array));
       expect(mockCleanupQueue.add).not.toHaveBeenCalled();
       expect(logger.warn).toHaveBeenCalledWith(
         'Job failed. Temporary files will NOT be cleaned up to allow for manual inspection.',
       );
     });
 
-    it('should throw an error and not enqueue cleanup if icon generation fails', async () => {
+    it('should delegate to _reportErrorAndThrow if icon generation fails', async () => {
       const job = createMockJob({});
       const { logger } = await import('./logger.server');
       const iconError = new Error('Icon generation failed.');
@@ -435,18 +429,11 @@ describe('FlyerProcessingService', () => {
       // bubbling up from the icon generation step.
       vi.spyOn(FlyerDataTransformer.prototype, 'transform').mockRejectedValue(iconError);
 
+      const reportErrorSpy = vi.spyOn(service as any, '_reportErrorAndThrow');
+
       await expect(service.processJob(job)).rejects.toThrow('Icon generation failed.');
 
-      expect(job.updateProgress).toHaveBeenCalledWith({
-        errorCode: 'UNKNOWN_ERROR',
-        message: 'Icon generation failed.',
-        stages: [
-          { name: 'Preparing Inputs', status: 'completed', critical: true, detail: '1 page(s) ready for AI.' },
-          { name: 'Extracting Data with AI', status: 'completed', critical: true, detail: 'Communicating with AI model...' },
-          { name: 'Transforming AI Data', status: 'failed', critical: true, detail: 'Icon generation failed.' },
-          { name: 'Saving to Database', status: 'skipped', critical: true },
-        ],
-      }); // This was a duplicate, fixed.
+      expect(reportErrorSpy).toHaveBeenCalledWith(iconError, job, expect.any(Object), expect.any(Array));
       expect(mockCleanupQueue.add).not.toHaveBeenCalled();
       expect(logger.warn).toHaveBeenCalledWith(
         'Job failed. Temporary files will NOT be cleaned up to allow for manual inspection.',
@@ -454,8 +441,58 @@ describe('FlyerProcessingService', () => {
     });
   });
 
-  describe('_reportErrorAndThrow (private method)', () => {
-    it('should update progress and throw UnrecoverableError for quota messages', async () => {
+  describe('_reportErrorAndThrow (Error Reporting Logic)', () => {
+    it('should update progress with a generic error and re-throw', async () => {
+      const { logger } = await import('./logger.server');
+      const job = createMockJob({});
+      const genericError = new Error('A standard failure');
+      const initialStages = [
+        { name: 'Stage 1', status: 'completed', critical: true, detail: 'Done' },
+        { name: 'Stage 2', status: 'in-progress', critical: true, detail: 'Working...' },
+        { name: 'Stage 3', status: 'pending', critical: true, detail: 'Waiting...' },
+      ];
+      const privateMethod = (service as any)._reportErrorAndThrow;
+
+      await expect(privateMethod(genericError, job, logger, initialStages)).rejects.toThrow(genericError);
+
+      expect(job.updateProgress).toHaveBeenCalledWith({
+        errorCode: 'UNKNOWN_ERROR',
+        message: 'A standard failure',
+        stages: [
+          { name: 'Stage 1', status: 'completed', critical: true, detail: 'Done' },
+          { name: 'Stage 2', status: 'failed', critical: true, detail: 'A standard failure' },
+          { name: 'Stage 3', status: 'skipped', critical: true },
+        ],
+      });
+    });
+
+    it('should use toErrorPayload for FlyerProcessingError instances', async () => {
+      const { logger } = await import('./logger.server');
+      const job = createMockJob({});
+      const validationError = new AiDataValidationError(
+        'Validation failed',
+        { foo: 'bar' },
+        { raw: 'data' },
+      );
+      const initialStages = [
+        { name: 'Extracting Data with AI', status: 'in-progress', critical: true, detail: '...' },
+      ];
+      const privateMethod = (service as any)._reportErrorAndThrow;
+
+      await expect(privateMethod(validationError, job, logger, initialStages)).rejects.toThrow(validationError);
+
+      expect(job.updateProgress).toHaveBeenCalledWith({
+        errorCode: 'AI_VALIDATION_FAILED',
+        message: "The AI couldn't read the flyer's format. Please try a clearer image or a different flyer.",
+        validationErrors: { foo: 'bar' },
+        rawData: { raw: 'data' },
+        stages: [
+          { name: 'Extracting Data with AI', status: 'failed', critical: true, detail: "The AI couldn't read the flyer's format. Please try a clearer image or a different flyer." },
+        ],
+      });
+    });
+
+    it('should throw UnrecoverableError for quota messages', async () => {
       const { logger } = await import('./logger.server');
       const job = createMockJob({});
       const quotaError = new Error('RESOURCE_EXHAUSTED');
@@ -472,53 +509,35 @@ describe('FlyerProcessingService', () => {
       });
     });
 
-    it('should use toErrorPayload for FlyerProcessingError instances', async () => {
-      const { logger } = await import('./logger.server');
-      const job = createMockJob({});
-      const validationError = new AiDataValidationError(
-        'Validation failed',
-        { foo: 'bar' },
-        { raw: 'data' },
-      );
-      const privateMethod = (service as any)._reportErrorAndThrow;
-
-      await expect(privateMethod(validationError, job, logger, [])).rejects.toThrow(
-        validationError,
-      );
-
-      // The payload should now come from the error's `toErrorPayload` method
-      expect(job.updateProgress).toHaveBeenCalledWith({
-        errorCode: 'AI_VALIDATION_FAILED',
-        message:
-          "The AI couldn't read the flyer's format. Please try a clearer image or a different flyer.",
-        validationErrors: { foo: 'bar' },
-        rawData: { raw: 'data' },
-        stages: [],
-      });
-    });
-
-    it('should update progress and re-throw standard errors', async () => {
-      const { logger } = await import('./logger.server');
-      const job = createMockJob({});
-      const genericError = new Error('A standard failure');
-      const privateMethod = (service as any)._reportErrorAndThrow;
-
-      await expect(privateMethod(genericError, job, logger, [])).rejects.toThrow(genericError);
-
-      expect(job.updateProgress).toHaveBeenCalledWith({
-        errorCode: 'UNKNOWN_ERROR',
-        message: 'A standard failure', // This was a duplicate, fixed.
-        stages: [],
-      });
-    });
-
     it('should wrap and throw non-Error objects', async () => {
       const { logger } = await import('./logger.server');
       const job = createMockJob({});
       const nonError = 'just a string error';
       const privateMethod = (service as any)._reportErrorAndThrow;
 
-      await expect(privateMethod(nonError, job, logger, [])).rejects.toThrow('just a string error');
+      await expect(privateMethod(nonError, job, logger, [])).rejects.toThrow(
+        'just a string error',
+      );
+    });
+
+    it('should correctly identify the failed stage based on error code', async () => {
+      const { logger } = await import('./logger.server');
+      const job = createMockJob({});
+      const pdfError = new PdfConversionError('PDF failed');
+      const initialStages = [
+        { name: 'Preparing Inputs', status: 'in-progress', critical: true, detail: '...' },
+        { name: 'Extracting Data with AI', status: 'pending', critical: true, detail: '...' },
+      ];
+      const privateMethod = (service as any)._reportErrorAndThrow;
+
+      await expect(privateMethod(pdfError, job, logger, initialStages)).rejects.toThrow(pdfError);
+
+      expect(job.updateProgress).toHaveBeenCalledWith(expect.objectContaining({
+        stages: [
+          { name: 'Preparing Inputs', status: 'failed', critical: true, detail: expect.any(String) },
+          { name: 'Extracting Data with AI', status: 'skipped', critical: true },
+        ],
+      }));
     });
   });
 

src/services/systemService.test.ts

@@ -12,38 +12,6 @@ vi.mock('./logger.server', () => ({
   },
 }));
 
-// Mock util.promisify to handle child_process.exec signature
-vi.mock('util', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('util')>();
-  return {
-    ...actual,
-    promisify: (fn: Function) => {
-      return (...args: any[]) => {
-        return new Promise((resolve, reject) => {
-          fn(...args, (err: Error | null, stdout: string, stderr: string) => {
-            if (err) {
-              // Attach stdout/stderr to error for the catch block in service
-              Object.assign(err, { stdout, stderr });
-              reject(err);
-            } else {
-              resolve({ stdout, stderr });
-            }
-          });
-        });
-      };
-    },
-  };
-});
-
-// Mock child_process
-vi.mock('child_process', async (importOriginal) => {
-  const actual = await importOriginal<typeof import('child_process')>();
-  return {
-    ...actual,
-    exec: vi.fn(),
-  };
-});
-
 // Import service AFTER mocks to ensure top-level promisify uses the mock
 import { systemService } from './systemService';
 

src/services/systemService.ts

@@ -4,6 +4,8 @@ import { promisify } from 'util';
 import { logger } from './logger.server';
 
 const execAsync = promisify(exec);
+logger.debug({ typeOfExec: typeof exec, isExecFunction: typeof exec === 'function' }, 'SystemService: Initializing execAsync');
+logger.debug({ typeOfPromisify: typeof promisify, isPromisifyFunction: typeof promisify === 'function' }, 'SystemService: Initializing execAsync');
 
 class SystemService {
   async getPm2Status(): Promise<{ success: boolean; message: string }> {

src/tests/setup/tests-setup-unit.ts

@@ -116,6 +116,67 @@ afterEach(cleanup);
 // By placing mocks here, they are guaranteed to be hoisted and applied
 // before any test files are executed, preventing initialization errors.
 
+// --- Centralized Core Node/NPM Module Mocks ---
+
+// Mock 'util' to correctly handle the (err, stdout, stderr) signature of child_process.exec
+// when it's promisified. The standard util.promisify doesn't work on a simple vi.fn() mock.
+vi.mock('util', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('util')>();
+  return {
+    ...actual,
+    promisify: (fn: Function) => {
+      return (...args: any[]) => {
+        return new Promise((resolve, reject) => {
+          fn(...args, (err: Error | null, stdout: string, stderr: string) => {
+            if (err) {
+              // Attach stdout/stderr to the error object to mimic child_process.exec behavior
+              Object.assign(err, { stdout, stderr });
+              reject(err);
+            } else {
+              resolve({ stdout, stderr });
+            }
+          });
+        });
+      };
+    },
+  };
+});
+
+// Mock 'child_process' using the robust `importOriginal` pattern.
+// This preserves the module's structure and prevents "No default export" errors.
+vi.mock('child_process', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('child_process')>();
+  return {
+    ...actual,
+    // Provide a mock function for `exec` that can be implemented per-test.
+    exec: vi.fn(),
+  };
+});
+
+// Mock 'jsonwebtoken'. The `default` key is crucial because the code under test
+// uses `import jwt from 'jsonwebtoken'`, which imports the default export.
+vi.mock('jsonwebtoken', () => ({
+  default: {
+    sign: vi.fn(),
+    verify: vi.fn(),
+  },
+  // Also mock named exports for completeness.
+  sign: vi.fn(),
+  verify: vi.fn(),
+}));
+
+// Mock 'bcrypt'. The service uses `import * as bcrypt from 'bcrypt'`.
+vi.mock('bcrypt');
+
+// Mock 'crypto'. The service uses `import crypto from 'crypto'`.
+vi.mock('crypto', () => ({
+  default: {
+    randomBytes: vi.fn().mockReturnValue({
+      toString: vi.fn().mockReturnValue('mocked-random-string'),
+    }),
+  },
+}));
+
 // --- Global Mocks ---
 
 // 1. Define the mock pool instance logic OUTSIDE the factory so it can be used