cleaning up composite root setup

src/modules/cards/application/useCases/commands/AddCardToCollectionUseCase.ts

···
 
 export class AddCardToCollectionUseCase extends BaseUseCase<
   AddCardToCollectionDTO,
-  Result<AddCardToCollectionResponseDTO, ValidationError | AppError.UnexpectedError>
+  Result<
+    AddCardToCollectionResponseDTO,
+    ValidationError | AppError.UnexpectedError
+  >
 > {
   constructor(
     private cardRepository: ICardRepository,
-    private collectionRepository: ICollectionRepository,
     private cardCollectionService: CardCollectionService,
     eventPublisher: IEventPublisher,
   ) {

src/shared/infrastructure/http/factories/ServiceFactory.ts

···
 import { IEventPublisher } from '../../../application/events/IEventPublisher';
 import { QueueName } from '../../events/QueueConfig';
 import { RedisFactory } from '../../redis/RedisFactory';
+import { IEventSubscriber } from 'src/shared/application/events/IEventSubscriber';
 
 // Shared services needed by both web app and workers
 export interface SharedServices {
···
   cardLibraryService: CardLibraryService;
   cardCollectionService: CardCollectionService;
   authMiddleware: AuthMiddleware;
-  eventPublisher?: IEventPublisher;
+  eventPublisher: IEventPublisher;
 }
 
 // Worker specific services (includes subscribers)
 export interface WorkerServices extends SharedServices {
   redisConnection: Redis;
   eventPublisher: IEventPublisher;
-  createEventSubscriber: (queueName: QueueName) => BullMQEventSubscriber;
+  createEventSubscriber: (queueName: QueueName) => IEventSubscriber;
 }
 
 // Legacy interface for backward compatibility
···
     configService: EnvironmentConfigService,
     repositories: Repositories,
   ): WebAppServices {
-    const sharedServices = this.createSharedServices(configService, repositories);
-    
+    const sharedServices = this.createSharedServices(
+      configService,
+      repositories,
+    );
+
     const useMockAuth = process.env.USE_MOCK_AUTH === 'true';
 
     // OAuth Client (always create for real, but may not be used if mocking)
···
 
     const authMiddleware = new AuthMiddleware(sharedServices.tokenService);
 
-    // Optionally create event publisher for web app if Redis is available
-    let eventPublisher: IEventPublisher | undefined;
-    if (process.env.REDIS_URL && !process.env.USE_FAKE_PUBLISHERS) {
-      try {
-        const redisConnection = RedisFactory.createConnection();
-        eventPublisher = new BullMQEventPublisher(redisConnection);
-      } catch (error) {
-        console.warn('Failed to create Redis connection for event publisher:', error);
-      }
-    }
+    const redisConnection = RedisFactory.createConnection(
+      configService.getWorkersConfig().redisUrl,
+    );
+    const eventPublisher = new BullMQEventPublisher(redisConnection);
 
     return {
       ...sharedServices,
···
     configService: EnvironmentConfigService,
     repositories: Repositories,
   ): WorkerServices {
-    const sharedServices = this.createSharedServices(configService, repositories);
+    const sharedServices = this.createSharedServices(
+      configService,
+      repositories,
+    );
 
     // Redis connection is required for workers
     if (!process.env.REDIS_URL) {
-      throw new Error('REDIS_URL environment variable is required for worker services');
+      throw new Error(
+        'REDIS_URL environment variable is required for worker services',
+      );
     }
 
-    const redisConnection = RedisFactory.createConnection();
+    const redisUrl = configService.getWorkersConfig().redisUrl;
+    const redisConnection = RedisFactory.createConnection(redisUrl);
 
     const eventPublisher = new BullMQEventPublisher(redisConnection);
 

src/shared/infrastructure/http/factories/UseCaseFactory.ts

···
         services.metadataService,
         services.cardLibraryService,
         services.cardCollectionService,
+        services.eventPublisher,
       ),
       addCardToLibraryUseCase: new AddCardToLibraryUseCase(
         repositories.cardRepository,
···
       addCardToCollectionUseCase: new AddCardToCollectionUseCase(
         repositories.cardRepository,
         services.cardCollectionService,
+        services.eventPublisher,
       ),
       updateNoteCardUseCase: new UpdateNoteCardUseCase(
         repositories.cardRepository,
···
       createCollectionUseCase: new CreateCollectionUseCase(
         repositories.collectionRepository,
         services.collectionPublisher,
+        services.eventPublisher,
       ),
       updateCollectionUseCase: new UpdateCollectionUseCase(
         repositories.collectionRepository,

src/shared/infrastructure/redis/RedisFactory.ts

···
 import Redis from 'ioredis';
 
 export class RedisFactory {
-  static createConnection(redisUrl?: string): Redis {
-    const url = redisUrl || process.env.REDIS_URL || 'redis://localhost:6379';
-    
-    return new Redis(url, {
-      maxRetriesPerRequest: 3,
-      lazyConnect: true,
-      retryDelayOnFailover: 100,
-      enableReadyCheck: false,
-      maxRetriesPerRequest: null,
-    });
+  private static instance: Redis | null = null;
+  static createConnection(redisUrl: string): Redis {
+    if (!this.instance) {
+      this.instance = new Redis(redisUrl);
+    }
+    return this.instance;
   }
 }