Refactor encoding/decoding logic in ObjectMessage

Use `WireObjectMessage` to represent the message received from the
server which can be decoded into an `ObjectMessage`.
`ObjectMessage` can then be encoded into a `WireObjectMessage`.

Author: VeskeR

src/common/lib/client/realtimechannel.ts

@@ -17,7 +17,7 @@ import { normaliseChannelOptions } from '../util/defaults';
 import { PaginatedResult } from './paginatedresource';
 import type { PushChannel } from 'plugins/push';
 import type { WirePresenceMessage } from '../types/presencemessage';
-import type { Objects, ObjectMessage } from 'plugins/objects';
+import type { Objects, WireObjectMessage } from 'plugins/objects';
 import type RealtimePresence from './realtimepresence';
 import type RealtimeAnnotations from './realtimeannotations';
 
@@ -507,7 +507,7 @@ class RealtimeChannel extends EventEmitter {
     return this.sendMessage(msg);
   }
 
-  sendState(objectMessages: ObjectMessage[]): Promise<void> {
+  sendState(objectMessages: WireObjectMessage[]): Promise<void> {
     const msg = protocolMessageFromValues({
       action: actions.OBJECT,
       channel: this.name,
@@ -623,17 +623,12 @@ class RealtimeChannel extends EventEmitter {
         }
 
         populateFieldsFromParent(message);
-        const objectMessages = message.state;
         // need to use the active protocol format instead of just client's useBinaryProtocol option,
         // as comet transport does not support msgpack and will default to json without changing useBinaryProtocol.
         // message processing is done in the same event loop tick up until this point,
         // so we can reliably expect an active protocol to exist and be the one that received the object message.
         const format = this.client.connection.connectionManager.getActiveTransportFormat()!;
-        await Promise.all(
-          objectMessages.map((om) =>
-            this.client._objectsPlugin!.ObjectMessage.decode(om, this.client, this.logger, Logger, Utils, format),
-          ),
-        );
+        const objectMessages = message.state.map((om) => om.decode(this.client, format));
 
         if (message.action === actions.OBJECT) {
           this._objects.handleObjectMessages(objectMessages);

src/common/lib/types/protocolmessage.ts

@@ -68,10 +68,10 @@ export function fromDeserialized(
     );
   }
 
-  let state: ObjectsPlugin.ObjectMessage[] | undefined;
+  let state: ObjectsPlugin.WireObjectMessage[] | undefined;
   if (objectsPlugin && deserialized.state) {
-    state = objectsPlugin.ObjectMessage.fromValuesArray(
-      deserialized.state as ObjectsPlugin.ObjectMessage[],
+    state = objectsPlugin.WireObjectMessage.fromValuesArray(
+      deserialized.state as ObjectsPlugin.WireObjectMessage[],
       Utils,
       MessageEncoding,
     );
@@ -128,7 +128,7 @@ export function stringify(
   }
   if (msg.state && objectsPlugin) {
     result +=
-      '; state=' + toStringArray(objectsPlugin.ObjectMessage.fromValuesArray(msg.state, Utils, MessageEncoding));
+      '; state=' + toStringArray(objectsPlugin.WireObjectMessage.fromValuesArray(msg.state, Utils, MessageEncoding));
   }
   if (msg.error) result += '; error=' + ErrorInfo.fromValues(msg.error).toString();
   if (msg.auth && msg.auth.accessToken) result += '; token=' + msg.auth.accessToken;
@@ -169,7 +169,7 @@ class ProtocolMessage {
   /**
    * This will be undefined if we skipped decoding this property due to user not requesting Objects functionality — see {@link fromDeserialized}
    */
-  state?: ObjectsPlugin.ObjectMessage[]; // TR4r
+  state?: ObjectsPlugin.WireObjectMessage[]; // TR4r
   auth?: unknown;
   connectionDetails?: Record<string, unknown>;
   params?: Record<string, string>;

src/plugins/objects/index.ts

@@ -1,9 +1,10 @@
-import { ObjectMessage } from './objectmessage';
+import { ObjectMessage, WireObjectMessage } from './objectmessage';
 import { Objects } from './objects';
 
-export { Objects, ObjectMessage };
+export { Objects, ObjectMessage, WireObjectMessage };
 
 export default {
   Objects,
   ObjectMessage,
+  WireObjectMessage,
 };

src/plugins/objects/livecounter.ts

@@ -1,6 +1,14 @@
 import { LiveObject, LiveObjectData, LiveObjectUpdate, LiveObjectUpdateNoop } from './liveobject';
 import { ObjectId } from './objectid';
-import { ObjectMessage, ObjectOperation, ObjectOperationAction, ObjectsCounterOp, ObjectState } from './objectmessage';
+import {
+  encodeInitialValue,
+  ObjectData,
+  ObjectMessage,
+  ObjectOperation,
+  ObjectOperationAction,
+  ObjectsCounterOp,
+  ObjectState,
+} from './objectmessage';
 import { Objects } from './objects';
 
 export interface LiveCounterData extends LiveObjectData {
@@ -29,7 +37,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
    *
    * @internal
    */
-  static fromObjectState(objects: Objects, objectState: ObjectState): LiveCounter {
+  static fromObjectState(objects: Objects, objectState: ObjectState<ObjectData>): LiveCounter {
     const obj = new LiveCounter(objects, objectState.objectId);
     obj.overrideWithObjectState(objectState);
     return obj;
@@ -41,7 +49,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
    *
    * @internal
    */
-  static fromObjectOperation(objects: Objects, objectOperation: ObjectOperation): LiveCounter {
+  static fromObjectOperation(objects: Objects, objectOperation: ObjectOperation<ObjectData>): LiveCounter {
     const obj = new LiveCounter(objects, objectOperation.objectId);
     obj._mergeInitialDataFromCreateOperation(objectOperation);
     return obj;
@@ -63,7 +71,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
           action: ObjectOperationAction.COUNTER_INC,
           objectId,
           counterOp: { amount },
-        } as ObjectOperation,
+        } as ObjectOperation<ObjectData>,
       },
       client.Utils,
       client.MessageEncoding,
@@ -83,7 +91,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
     }
 
     const initialValueObj = LiveCounter.createInitialValueObject(count);
-    const { encodedInitialValue, format } = ObjectMessage.encodeInitialValue(initialValueObj, client);
+    const { encodedInitialValue, format } = encodeInitialValue(initialValueObj, client);
     const nonce = client.Utils.cheapRandStr();
     const msTimestamp = await client.getTimestamp(true);
 
@@ -104,7 +112,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
           nonce,
           initialValue: encodedInitialValue,
           initialValueEncoding: format,
-        } as ObjectOperation,
+        } as ObjectOperation<ObjectData>,
       },
       client.Utils,
       client.MessageEncoding,
@@ -116,7 +124,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
   /**
    * @internal
    */
-  static createInitialValueObject(count?: number): Pick<ObjectOperation, 'counter'> {
+  static createInitialValueObject(count?: number): Pick<ObjectOperation<ObjectData>, 'counter'> {
     return {
       counter: {
         count: count ?? 0,
@@ -162,7 +170,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
   /**
    * @internal
    */
-  applyOperation(op: ObjectOperation, msg: ObjectMessage): void {
+  applyOperation(op: ObjectOperation<ObjectData>, msg: ObjectMessage): void {
     if (op.objectId !== this.getObjectId()) {
       throw new this._client.ErrorInfo(
         `Cannot apply object operation with objectId=${op.objectId}, to this LiveCounter with objectId=${this.getObjectId()}`,
@@ -226,7 +234,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
    * @internal
    * @spec RTLC6
    */
-  overrideWithObjectState(objectState: ObjectState): LiveCounterUpdate | LiveObjectUpdateNoop {
+  overrideWithObjectState(objectState: ObjectState<ObjectData>): LiveCounterUpdate | LiveObjectUpdateNoop {
     if (objectState.objectId !== this.getObjectId()) {
       throw new this._client.ErrorInfo(
         `Invalid object state: object state objectId=${objectState.objectId}; LiveCounter objectId=${this.getObjectId()}`,
@@ -300,7 +308,7 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
     return { update: { amount: counterDiff } };
   }
 
-  protected _mergeInitialDataFromCreateOperation(objectOperation: ObjectOperation): LiveCounterUpdate {
+  protected _mergeInitialDataFromCreateOperation(objectOperation: ObjectOperation<ObjectData>): LiveCounterUpdate {
     // if a counter object is missing for the COUNTER_CREATE op, the initial value is implicitly 0 in this case.
     // note that it is intentional to SUM the incoming count from the create op.
     // if we got here, it means that current counter instance is missing the initial value in its data reference,
@@ -311,15 +319,15 @@ export class LiveCounter extends LiveObject<LiveCounterData, LiveCounterUpdate>
     return { update: { amount: objectOperation.counter?.count ?? 0 } };
   }
 
-  private _throwNoPayloadError(op: ObjectOperation): void {
+  private _throwNoPayloadError(op: ObjectOperation<ObjectData>): void {
     throw new this._client.ErrorInfo(
       `No payload found for ${op.action} op for LiveCounter objectId=${this.getObjectId()}`,
       92000,
       500,
     );
   }
 
-  private _applyCounterCreate(op: ObjectOperation): LiveCounterUpdate | LiveObjectUpdateNoop {
+  private _applyCounterCreate(op: ObjectOperation<ObjectData>): LiveCounterUpdate | LiveObjectUpdateNoop {
     if (this._createOperationIsMerged) {
       // There can't be two different create operation for the same object id, because the object id
       // fully encodes that operation. This means we can safely ignore any new incoming create operations