@player-tools/devtools-messenger 0.8.0-next.0 → 0.8.0

package/src/index.ts

@@ -12,7 +12,13 @@ import type {
   TransactionMetadata,
 } from "@player-tools/devtools-types";
 
-const counters: Record<string, number> = {};
+const internalEvents: Array<InternalEvent<BaseEvent<string, unknown>>["type"]> =
+  [
+    "MESSENGER_BEACON",
+    "MESSENGER_DISCONNECT",
+    "MESSENGER_REQUEST_LOST_EVENTS",
+    "MESSENGER_EVENT_BATCH",
+  ];
 
 /**
  * Messenger<EventsType>
@@ -57,14 +63,14 @@ const counters: Record<string, number> = {};
  *  ```
  */
 export class Messenger<T extends BaseEvent<string, unknown>> {
-  /** static record of events per context */
-  private static contextEvents: Record<
+  /** static record of events by isntance ID */
+  private static events: Record<
     string,
-    Array<BaseEvent<string, unknown>>
+    Array<MessageEvent<BaseEvent<string, unknown>>>
   > = {};
 
-  /** connections record */
-  private connections: Record<string, Connection> = {};
+  /** static connections record by instance ID */
+  private static connections: Record<string, Record<string, Connection>> = {};
 
   /** beacon interval */
   private beaconInterval: NodeJS.Timeout | null = null;
@@ -96,11 +102,6 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
 
     // add listener:
     this.options.addListener(this.handleMessage);
-
-    // if events for this context don't exist, create an empty array
-    if (!(Messenger.contextEvents[this.options.context] as T[])) {
-      (Messenger.contextEvents[this.options.context] as T[]) = [];
-    }
   }
 
   private log(message: string) {
@@ -111,40 +112,62 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
     }
   }
 
-  /** generate a sequential id for each non-internal message */
-  private getTransactionID(message: MessengerEvent<T>, target?: string) {
-    const internalEvents: Array<InternalEvent<T>["type"]> = [
-      "MESSENGER_BEACON",
-      "MESSENGER_DISCONNECT",
-      "MESSENGER_REQUEST_LOST_EVENTS",
-      "MESSENGER_EVENT_BATCH",
-    ];
+  private getConnection(id: string) {
+    if (!Messenger.connections[this.id]) {
+      Messenger.connections[this.id] = {};
+    }
+
+    return Messenger.connections[this.id][id];
+  }
+
+  private addConnection(id: string) {
+    Messenger.connections[this.id][id] = {
+      id,
+      messagesReceived: 0,
+      messagesSent: 0,
+      desync: false,
+    };
+  }
+
+  private getEvents() {
+    if (!Messenger.events[this.id]) {
+      Messenger.events[this.id] = [];
+    }
 
+    return Messenger.events[this.id] as unknown as MessengerEvent<T>[];
+  }
+
+  private addEvent(event: MessengerEvent<T>) {
+    const events = this.getEvents();
+    events.push(event);
+  }
+
+  /** generate a sequential id for each non-internal message */
+  private getTransactionID(message: MessengerEvent<T>) {
     if (
-      !target ||
+      !message.target ||
       internalEvents.includes(message.type as InternalEvent<T>["type"])
     ) {
       return -1;
     }
 
-    if (!counters[target]) {
-      counters[target] = 0;
+    if (!this.getConnection(message.target)) {
+      this.addConnection(message.target);
     }
 
-    return counters[target]++;
+    const connection = this.getConnection(message.target);
+    connection.messagesSent += 1;
+    return connection.messagesSent;
   }
 
-  private addTransactionMetadata(
-    event: MessengerEvent<T>,
-    target?: string
-  ): Transaction<T> {
+  private addTransactionMetadata(event: MessengerEvent<T>): Transaction<T> {
     const metadata = {
       _messenger_: true,
-      id: this.getTransactionID(event, target),
+      id: this.getTransactionID(event),
       sender: this.id,
       timestamp: Date.now(),
       context: this.options.context,
-      ...(target && { target }),
+      ...(event.target && { target: event.target }),
     };
 
     return {
@@ -171,8 +194,9 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
     const isFromMessenger = parsed._messenger_;
     const isFromSelf = parsed.sender === this.id;
     const isFromSameContext = parsed.context === this.options.context;
-    const isTargetingOthers = parsed.target && parsed.target !== this.id;
-    const isKnownConnection = this.connections[parsed.sender];
+    const isTargetingOthers = parsed.target ? parsed.target !== this.id : false;
+    const connection = this.getConnection(parsed.sender);
+    const isKnownConnection = Boolean(connection);
 
     if (
       !isFromMessenger ||
@@ -200,25 +224,29 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
     if (isKnownConnection) {
       const isBatch = parsed.type === "MESSENGER_EVENT_BATCH";
 
-      // if batch, get the first message id, so we can check for missing messages:
       const transactionID = isBatch
         ? (parsed.payload as EventsBatchEvent<T>["payload"]).events[0].id
         : parsed.id;
 
-      const { lastReceivedMessageId, desync } = this.connections[parsed.sender];
+      const { messagesReceived, desync } = connection;
 
       // if we already received this message, ignore:
-      if (transactionID <= lastReceivedMessageId) {
+      if (transactionID > -1 && transactionID <= messagesReceived) {
         return;
       }
 
       // if we missed messages, request them, unless we already did:
-      if (!desync && transactionID > lastReceivedMessageId + 1) {
+      if (
+        !desync &&
+        transactionID > -1 &&
+        transactionID > messagesReceived + 1
+      ) {
         const message: RequestLostEventsEvent = {
           type: "MESSENGER_REQUEST_LOST_EVENTS",
           payload: {
-            lastReceivedMessageId,
+            messagesReceived,
           },
+          target: parsed.sender,
         };
 
         this.options.sendMessage(this.addTransactionMetadata(message));
@@ -228,7 +256,7 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
         );
 
         // set desync, so we don't request again:
-        this.connections[parsed.sender].desync = true;
+        connection.desync = true;
 
         // don't process this message, since we requested missing ones:
         return;
@@ -236,17 +264,13 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
 
       if (isBatch) {
         // clear desync flag on event batch:
-        this.connections[parsed.sender].desync = false;
+        connection.desync = false;
+        connection.messagesReceived += (
+          parsed.payload as EventsBatchEvent<T>["payload"]
+        ).events.length;
+      } else {
+        connection.messagesReceived += 1;
       }
-
-      // if batch, get the last message id:
-      const newLastMessageIdx = isBatch
-        ? (parsed.payload as EventsBatchEvent<T>["payload"]).events.slice(-1)[0]
-            .id
-        : parsed.id;
-
-      // update last received message id:
-      this.connections[parsed.sender].lastReceivedMessageId = newLastMessageIdx;
     }
 
     this.options.messageCallback(parsed);
@@ -257,74 +281,76 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
   }
 
   private handleBeaconMessage(parsed: Transaction<T>) {
-    // if we reach here, we assume a new connection and send all events:
-    if ((Messenger.contextEvents[this.options.context] as T[]).length > 0) {
+    if (this.getConnection(parsed.sender)) {
+      return;
+    }
+
+    this.addConnection(parsed.sender);
+    const events = this.getEvents();
+
+    if (events.length > 0) {
       const message: EventsBatchEvent<T> = {
         type: "MESSENGER_EVENT_BATCH",
         payload: {
-          events: (Messenger.contextEvents[this.options.context] as T[]).map(
-            (event) => this.addTransactionMetadata(event, parsed.sender)
-          ),
+          events: events.map((event) => this.addTransactionMetadata(event)),
         },
+        target: parsed.sender,
       };
 
-      this.options.sendMessage(
-        this.addTransactionMetadata(message, parsed.sender)
-      );
+      this.options.sendMessage(this.addTransactionMetadata(message));
 
       this.log(
-        `messages [0 - ${
-          (Messenger.contextEvents[this.options.context] as T[]).length - 1
-        }] sent to ${parsed.context}:${parsed.sender}`
+        `messages [0 - ${events.length - 1}] sent to ${parsed.context}:${
+          parsed.sender
+        }`
       );
-    }
-
-    const newConnection: Connection = {
-      id: parsed.sender,
-      lastSentMessageId:
-        (Messenger.contextEvents[this.options.context] as T[]).length - 1,
-      lastReceivedMessageId: -1,
-      desync: false,
-    };
 
-    this.connections[parsed.sender] = newConnection;
+      const connection = this.getConnection(parsed.sender);
+      connection.messagesSent = events.length;
+    }
 
     this.log(`new connection added - ${parsed.context}:${parsed.sender}`);
   }
 
   private handleLostEventsRequest(parsed: Transaction<T>) {
-    const lastMessageIdx = (parsed.payload as RequestLostEventsEvent["payload"])
-      .lastReceivedMessageId;
-
-    const missingEvents = (
-      Messenger.contextEvents[this.options.context] as T[]
-    ).slice(
-      lastMessageIdx + 1,
-      (Messenger.contextEvents[this.options.context] as T[]).length
-    );
+    const connection = this.getConnection(parsed.sender);
+    const events = this.getEvents();
+
+    if (!connection || events.length === 0) {
+      return;
+    }
+
+    const missingEvents = events.slice(connection.messagesSent, events.length);
+
+    if (missingEvents.length === 0) {
+      return;
+    }
 
     const message: EventsBatchEvent<T> = {
       type: "MESSENGER_EVENT_BATCH",
       payload: {
         events: missingEvents.map((event) =>
-          this.addTransactionMetadata(event, parsed.sender)
+          this.addTransactionMetadata(event)
         ),
       },
+      target: parsed.sender,
     };
 
     this.options.sendMessage(this.addTransactionMetadata(message));
 
+    connection.messagesSent = events.length;
+
     this.log(
-      `messages [0 - ${
-        (Messenger.contextEvents[this.options.context] as T[]).length - 1
-      }] sent to ${parsed.context}:${parsed.sender}`
+      `messages [0 - ${events.length - 1}] sent to ${parsed.context}:${
+        parsed.sender
+      }`
     );
   }
 
   private handleDisconnectMessage(
     parsed: TransactionMetadata & MessengerEvent<T>
   ) {
-    delete this.connections[parsed.sender];
+    delete Messenger.connections[parsed.sender];
 
     this.log(`disconnected - ${parsed.context}:${parsed.sender}`);
   }
@@ -333,26 +359,24 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
     const parsed: T =
       typeof message === "string" ? JSON.parse(message) : message;
 
-    (Messenger.contextEvents[this.options.context] as T[]).push(parsed);
-
-    // send to all connections:
-    Object.values(this.connections).forEach(({ id }) => {
-      const msg = this.addTransactionMetadata(parsed, id);
-
-      this.options
-        .sendMessage(msg)
-        .then(() => {
-          this.connections[id].lastSentMessageId = msg.id;
-        })
-        .catch(() => {
-          this.options.handleFailedMessage?.(msg);
-
-          this.log(
-            `message failed: ${msg.context}:${id} - index: ${
-              (Messenger.contextEvents[this.options.context] as T[]).length
-            }`
-          );
-        });
+    this.addEvent(parsed);
+
+    const target = parsed.target || null;
+    const msg = this.addTransactionMetadata(parsed);
+    const connection = target ? this.getConnection(target) : null;
+
+    if (connection) {
+      connection.messagesSent += 1;
+    }
+
+    this.options.sendMessage(msg).catch(() => {
+      this.options.handleFailedMessage?.(msg);
+
+      this.log(
+        `failed to send message: ${
+          (parsed as BaseEvent<string, unknown>).type
+        } from ${this.id} to ${target || "all"}`
+      );
     });
   }
 
@@ -363,19 +387,23 @@ export class Messenger<T extends BaseEvent<string, unknown>> {
 
     this.options.removeListener(this.handleMessage);
 
-    Object.keys(this.connections).forEach((connection) => {
+    Object.keys(Messenger.connections).forEach((connection) => {
       const event: DisconnectEvent = {
         type: "MESSENGER_DISCONNECT",
         payload: null,
+        target: connection,
       };
-      const message = this.addTransactionMetadata(event, connection);
+      const message = this.addTransactionMetadata(event);
       this.options.sendMessage(message);
     });
 
+    Messenger.reset();
     this.log("destroyed");
   }
 
-  static resetEvents() {
-    Messenger.contextEvents = {};
+  /** reset static records */
+  static reset() {
+    Messenger.events = {};
+    Messenger.connections = {};
   }
 }

package/types/index.d.ts

@@ -43,10 +43,10 @@ import type { BaseEvent, MessengerOptions } from "@player-tools/devtools-types";
  */
 export declare class Messenger<T extends BaseEvent<string, unknown>> {
     private options;
-    /** static record of events per context */
-    private static contextEvents;
-    /** connections record */
-    private connections;
+    /** static record of events by isntance ID */
+    private static events;
+    /** static connections record by instance ID */
+    private static connections;
     /** beacon interval */
     private beaconInterval;
     /** time between beacons milliseconds */
@@ -57,6 +57,10 @@ export declare class Messenger<T extends BaseEvent<string, unknown>> {
     private id;
     constructor(options: MessengerOptions<T>);
     private log;
+    private getConnection;
+    private addConnection;
+    private getEvents;
+    private addEvent;
     /** generate a sequential id for each non-internal message */
     private getTransactionID;
     private addTransactionMetadata;
@@ -69,6 +73,7 @@ export declare class Messenger<T extends BaseEvent<string, unknown>> {
     private handleDisconnectMessage;
     sendMessage(message: T | string): void;
     destroy(): void;
-    static resetEvents(): void;
+    /** reset static records */
+    static reset(): void;
 }
 //# sourceMappingURL=index.d.ts.map