ci: Bump version to 0.9.65 [skip ci]

package-lock.json

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

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

@@ -244,8 +244,9 @@ describe('Flyer DB Service', () => {
       await expect(flyerRepo.insertFlyer(flyerData, mockLogger)).rejects.toThrow(
         CheckConstraintError,
       );
+      // The implementation now generates a more detailed error message.
       await expect(flyerRepo.insertFlyer(flyerData, mockLogger)).rejects.toThrow(
-        'Invalid URL format provided for image or icon.',
+        "[URL_CHECK_FAIL] Invalid URL format. Image: 'https://example.com/not-a-url', Icon: 'null'",
       );
     });
   });

src/services/logger.server.test.ts

@@ -1,6 +1,9 @@
 // src/services/logger.server.test.ts
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 
+// Unmock the module we are testing to override the global mock from setupFiles.
+vi.unmock('./logger.server');
+
 // Mock pino before importing the logger
 const pinoMock = vi.fn(() => ({
   info: vi.fn(),
@@ -25,14 +28,25 @@ describe('Server Logger', () => {
   it('should initialize pino with the correct level for production', async () => {
     vi.stubEnv('NODE_ENV', 'production');
     await import('./logger.server');
-    expect(pinoMock).toHaveBeenCalledWith(expect.objectContaining({ level: 'info' }));
+    expect(pinoMock).toHaveBeenCalledWith(
+      expect.objectContaining({ level: 'info', transport: undefined }),
+    );
   });
 
   it('should initialize pino with pretty-print transport for development', async () => {
     vi.stubEnv('NODE_ENV', 'development');
     await import('./logger.server');
     expect(pinoMock).toHaveBeenCalledWith(
-      expect.objectContaining({ transport: expect.any(Object) }),
+      expect.objectContaining({ level: 'debug', transport: expect.any(Object) }),
+    );
+  });
+
+  it('should initialize pino with debug level and no transport for test', async () => {
+    // This is the default for vitest, but we stub it for clarity.
+    vi.stubEnv('NODE_ENV', 'test');
+    await import('./logger.server');
+    expect(pinoMock).toHaveBeenCalledWith(
+      expect.objectContaining({ level: 'debug', transport: undefined }),
     );
   });
 });

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

@@ -59,17 +59,40 @@ vi.mock('../../services/storage/storageService', () => {
   };
 });
 
-// FIX: Import the singleton instance directly to spy on it
-import { aiService } from '../../services/aiService.server';
-
-
 /**
  * @vitest-environment node
  */
 
-const { mockExtractCoreData } = vi.hoisted(() => ({
-  mockExtractCoreData: vi.fn(),
-}));
+// CRITICAL: This mock function must be declared with vi.hoisted() to ensure it's available
+// at the module level BEFORE any imports are resolved.
+const { mockExtractCoreData } = vi.hoisted(() => {
+  return {
+    mockExtractCoreData: vi.fn(),
+  };
+});
+
+// CRITICAL: Mock the aiService module BEFORE any other imports that depend on it.
+// This ensures workers get the mocked version, not the real one.
+// We use a partial mock that only overrides extractCoreDataFromFlyerImage.
+vi.mock('../../services/aiService.server', async (importOriginal) => {
+  const actual = await importOriginal<typeof import('../../services/aiService.server')>();
+
+  // Create a proxy around the actual aiService that intercepts extractCoreDataFromFlyerImage
+  const proxiedAiService = new Proxy(actual.aiService, {
+    get(target, prop) {
+      if (prop === 'extractCoreDataFromFlyerImage') {
+        return mockExtractCoreData;
+      }
+      // For all other properties/methods, return the original
+      return target[prop as keyof typeof target];
+    },
+  });
+
+  return {
+    ...actual,
+    aiService: proxiedAiService,
+  };
+});
 
 // Mock the connection DB service to intercept withTransaction.
 // This is crucial because FlyerPersistenceService imports directly from connection.db,
@@ -99,9 +122,8 @@ describe('Flyer Processing Background Job Integration Test', () => {
     process.env.FRONTEND_URL = 'https://example.com';
     console.error('[TEST SETUP] FRONTEND_URL stubbed to:', process.env.FRONTEND_URL);
 
-    // FIX: Spy on the actual singleton instance. This ensures that when the worker
-    // imports 'aiService', it gets the instance we are controlling here.
-    vi.spyOn(aiService, 'extractCoreDataFromFlyerImage').mockImplementation(mockExtractCoreData);
+    // NOTE: The aiService mock is now set up via vi.mock() at the module level (above).
+    // This ensures workers get the mocked version when they import aiService.
 
     // NEW: Import workers to start them IN-PROCESS.
     // This ensures they run in the same memory space as our mocks.

src/tests/setup/integration-global-setup.ts

@@ -9,6 +9,29 @@ let server: Server;
 // This will hold the single database pool instance for the entire test run.
 let globalPool: ReturnType<typeof getPool> | null = null;
 
+/**
+ * Cleans all BullMQ queues to ensure no stale jobs from previous test runs.
+ * This is critical because old jobs with outdated error messages can pollute test results.
+ */
+async function cleanAllQueues() {
+  console.log(`[PID:${process.pid}] Cleaning all BullMQ queues...`);
+  const { flyerQueue, cleanupQueue, emailQueue, analyticsQueue, weeklyAnalyticsQueue, tokenCleanupQueue } = await import('../../services/queues.server');
+
+  const queues = [flyerQueue, cleanupQueue, emailQueue, analyticsQueue, weeklyAnalyticsQueue, tokenCleanupQueue];
+
+  for (const queue of queues) {
+    try {
+      // obliterate() removes ALL data associated with the queue from Redis
+      await queue.obliterate({ force: true });
+      console.log(`  ✅ Cleaned queue: ${queue.name}`);
+    } catch (error) {
+      // Log but don't fail - the queue might not exist yet
+      console.log(`  ⚠️ Could not clean queue ${queue.name}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+  console.log(`✅ [PID:${process.pid}] All queues cleaned.`);
+}
+
 export async function setup() {
   // Ensure we are in the correct environment for these tests.
   process.env.NODE_ENV = 'test';
@@ -17,6 +40,10 @@ export async function setup() {
 
   console.log(`\n--- [PID:${process.pid}] Running Integration Test GLOBAL Setup ---`);
 
+  // CRITICAL: Clean all queues BEFORE running any tests to remove stale jobs
+  // from previous test runs that may have outdated error messages.
+  await cleanAllQueues();
+
   // The integration setup is now the single source of truth for preparing the test DB.
   // It runs the same seed script that `npm run db:reset:test` used.
   try {

src/utils/serverUtils.test.ts

@@ -20,57 +20,79 @@ const createMockLogger = (): Logger =>
 
 describe('serverUtils', () => {
   describe('getBaseUrl', () => {
-    const originalEnv = process.env;
     let mockLogger: Logger;
 
     beforeEach(() => {
       // Reset mocks and environment variables before each test for isolation
       vi.resetModules();
-      process.env = { ...originalEnv };
+      vi.unstubAllEnvs();
       mockLogger = createMockLogger();
     });
 
     afterEach(() => {
       // Restore original environment variables after each test
-      process.env = originalEnv;
+      vi.unstubAllEnvs();
     });
 
     it('should use FRONTEND_URL if it is a valid URL', () => {
-      process.env.FRONTEND_URL = 'https://valid.example.com';
+      vi.stubEnv('FRONTEND_URL', 'https://valid.example.com');
       const baseUrl = getBaseUrl(mockLogger);
       expect(baseUrl).toBe('https://valid.example.com');
       expect(mockLogger.warn).not.toHaveBeenCalled();
     });
 
     it('should trim a trailing slash from FRONTEND_URL', () => {
-      process.env.FRONTEND_URL = 'https://valid.example.com/';
+      vi.stubEnv('FRONTEND_URL', 'https://valid.example.com/');
       const baseUrl = getBaseUrl(mockLogger);
       expect(baseUrl).toBe('https://valid.example.com');
     });
 
     it('should use BASE_URL if FRONTEND_URL is not set', () => {
-      delete process.env.FRONTEND_URL;
-      process.env.BASE_URL = 'https://base.example.com';
+      vi.stubEnv('BASE_URL', 'https://base.example.com');
       const baseUrl = getBaseUrl(mockLogger);
       expect(baseUrl).toBe('https://base.example.com');
       expect(mockLogger.warn).not.toHaveBeenCalled();
     });
 
-    it('should fall back to example.com with default port 3000 if no URL is provided', () => {
-      delete process.env.FRONTEND_URL;
-      delete process.env.BASE_URL;
-      delete process.env.PORT;
+    it('should fall back to localhost with default port 3000 in test environment', () => {
+      vi.stubEnv('NODE_ENV', 'test');
       const baseUrl = getBaseUrl(mockLogger);
-      expect(baseUrl).toBe('https://example.com:3000');
+      expect(baseUrl).toBe('http://localhost:3000');
       expect(mockLogger.warn).not.toHaveBeenCalled();
     });
 
-    it('should log a warning and fall back if FRONTEND_URL is invalid (does not start with http)', () => {
-      process.env.FRONTEND_URL = 'invalid.url.com';
+    it('should fall back to example.com in non-test environment', () => {
+      vi.stubEnv('NODE_ENV', 'development');
+      vi.stubEnv('PORT', '4000');
       const baseUrl = getBaseUrl(mockLogger);
-      expect(baseUrl).toBe('https://example.com:3000');
+      expect(baseUrl).toBe('http://example.com:4000');
+      expect(mockLogger.warn).not.toHaveBeenCalled();
+    });
+
+    it('should log a warning and fall back to localhost if FRONTEND_URL is invalid in test env', () => {
+      vi.stubEnv('NODE_ENV', 'test');
+      vi.stubEnv('FRONTEND_URL', 'invalid.url.com');
+      const baseUrl = getBaseUrl(mockLogger);
+      expect(baseUrl).toBe('http://localhost:3000');
       expect(mockLogger.warn).toHaveBeenCalledWith(
-        "[getBaseUrl] FRONTEND_URL/BASE_URL is invalid or incomplete ('invalid.url.com'). Falling back to default local URL: https://example.com:3000",
+        "[getBaseUrl] FRONTEND_URL/BASE_URL is invalid or incomplete ('invalid.url.com'). Falling back to: http://localhost:3000",
+      );
+    });
+
+    it('should log a warning and fall back to example.com if FRONTEND_URL is invalid in non-test env', () => {
+      vi.stubEnv('NODE_ENV', 'production');
+      vi.stubEnv('FRONTEND_URL', 'invalid.url.com');
+      const baseUrl = getBaseUrl(mockLogger);
+      expect(baseUrl).toBe('http://example.com:3000');
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        "[getBaseUrl] FRONTEND_URL/BASE_URL is invalid or incomplete ('invalid.url.com'). Falling back to: http://example.com:3000",
+      );
+    });
+
+    it('should throw an error if the final URL is invalid', () => {
+      vi.stubEnv('FRONTEND_URL', 'http:invalid');
+      expect(() => getBaseUrl(mockLogger)).toThrow(
+        `[getBaseUrl] Generated URL 'http:invalid' does not match required pattern (must start with http:// or https://)`,
       );
     });
   });