x

Author: ricardogarim

packages/homeserver/src/homeserver.module.ts

@@ -11,7 +11,9 @@ import { DatabaseConnection } from './database/database.connection';
 import { MissingEventListener } from './listeners/missing-event.listener';
 import { StagingAreaListener } from './listeners/staging-area.listener';
 import { HttpLoggerMiddleware } from './middleware/http-logger.middleware';
+import { MissingEventsQueue } from './queues/missing-event.queue';
 import { QueueModule } from './queues/queue.module';
+import { StagingAreaQueue } from './queues/staging-area.queue';
 import { EventRepository } from './repositories/event.repository';
 import { KeyRepository } from './repositories/key.repository';
 import { RoomRepository } from './repositories/room.repository';
@@ -28,6 +30,11 @@ import { ProfilesService } from './services/profiles.service';
 import { RoomService } from './services/room.service';
 import { ServerService } from './services/server.service';
 import { StagingAreaService } from './services/staging-area.service';
+import { DownloadedEventValidationPipeline } from './validation/pipelines/DownloadedEventValidationPipeline';
+import { SynchronousEventReceptionPipeline } from './validation/pipelines/synchronousEventReceptionPipeline';
+import { EventFormatValidator } from './validation/validators/EventFormatValidator';
+import { EventHashesAndSignaturesValidator } from './validation/validators/EventHashesAndSignaturesValidator';
+import { EventTypeSpecificValidator } from './validation/validators/EventTypeSpecificValidator';
 
 const CONFIG_PROVIDER = {
   provide: ConfigService,
@@ -39,25 +46,45 @@ const CONFIG_PROVIDER = {
     QueueModule
   ],
   providers: [
+    // Core services
     CONFIG_PROVIDER,
     DatabaseConnection,
-    EventRepository,
     EventService,
-    InviteService,
     MissingEventService,
-    ProfilesService,
     StagingAreaService,
-    MissingEventListener,
-    StagingAreaListener,
-    ServerRepository,
-    ServerService,
-    RoomRepository,
-    RoomService,
-    EventStateService,
+    
+    // Event processing services
     EventAuthorizationService,
-    NotificationService,
+    EventStateService,
     FederationService,
+    NotificationService,
+    InviteService,
+    ProfilesService,
+    ServerService,
+    RoomService,
+    
+    // Repositories
+    EventRepository,
+    RoomRepository,
     KeyRepository,
+    ServerRepository,
+    
+    // Queues
+    MissingEventsQueue,
+    StagingAreaQueue,
+    
+    // Listeners
+    MissingEventListener,
+    StagingAreaListener,
+    
+    // Validation pipelines
+    DownloadedEventValidationPipeline,
+    SynchronousEventReceptionPipeline,
+    
+    // Validators
+    EventFormatValidator,
+    EventHashesAndSignaturesValidator,
+    EventTypeSpecificValidator,
   ],
   controllers: [
     PingController,

packages/homeserver/src/listeners/missing-event.listener.ts

@@ -6,29 +6,27 @@ import { ConfigService } from '../services/config.service';
 import { EventService } from '../services/event.service';
 import { StagingAreaService } from '../services/staging-area.service';
 import { Logger } from '../utils/logger';
-import { DownloadedEventValidationPipeline } from '../validation/pipelines/DownloadedEventValidationPipeline';
 
 @Injectable()
 export class MissingEventListener {
   private readonly logger = new Logger('MissingEventListener');
   private readonly eventFetcher: EventFetcher;
-  private readonly seenEvents = new Set<string>(); // Track events we've already tried to fetch
+  private readonly seenEvents = new Set<string>();
 
   constructor(
     @Inject(forwardRef(() => MissingEventsQueue)) private readonly missingEventsQueue: MissingEventsQueue,
     @Inject(forwardRef(() => StagingAreaQueue)) private readonly stagingAreaQueue: StagingAreaQueue,
     @Inject(forwardRef(() => StagingAreaService)) private readonly stagingAreaService: StagingAreaService,
     @Inject(EventService) private readonly eventService: EventService,
-    @Inject(ConfigService) private readonly configService: ConfigService,
-    @Inject(DownloadedEventValidationPipeline) private readonly eventValidationPipeline: DownloadedEventValidationPipeline,
+    @Inject(ConfigService) private readonly configService: ConfigService
   ) {
     this.missingEventsQueue.registerHandler(this.handleQueueItem.bind(this));
 
     this.eventFetcher = new EventFetcher({
       config: {
         name: this.configService.getServerName(),
         signingKey: this.configService.getSigningKey(),
-        debug: this.configService.isDebugEnabled()
+        debug: true
       }
     });
   }
@@ -66,29 +64,16 @@ export class MissingEventListener {
         return;
       }
 
-      const validationContext = {
-        config: {
-          name: this.configService.getServerName(),
-          signingKey: this.configService.getSigningKey()
-        }
-      };
-      
-      const validatedEvents = await this.eventValidationPipeline.validate(
-        fetchedEvents.events.map(e => e.event), 
-        validationContext
-      );
-      
+      // Process fetched events directly without validation pipeline
+      // We'll use the standard event processing flow instead
       let addedCount = 0;
-      for (const validatedEvent of validatedEvents.pdus) {
-        if ('errcode' in validatedEvent) {
-          this.logger.warn(`Validation failed for event: ${validatedEvent.error}`);
-          continue;
-        }
-        
-        const event = validatedEvent.event;
+      for (const eventData of fetchedEvents.events) {
+        const event = eventData.event;
 
+        // Add the event to the staging area for processing
+        // It will go through normal validation there
         this.stagingAreaService.addEventToQueue({
-          eventId: event.event_id || event.eventId,
+          eventId: event.event_id || eventData.eventId,
           roomId: event.room_id,
           origin: event.origin || origin,
           event