@fluidframework/sequence 1.0.1 → 1.1.0

package/src/defaultMap.ts

@@ -24,6 +24,7 @@ import {
     IValueType,
     IValueTypeOperationValue,
     ISharedDefaultMapEvents,
+    IMapMessageLocalMetadata,
 } from "./defaultMapInterfaces";
 
 /**
@@ -49,13 +50,11 @@ interface IMapMessageHandler {
      * Communicate the operation to remote clients.
      * @param op - The map operation to submit
      */
-    submit(op: IMapOperation): void;
+    submit(op: IMapOperation, localOpMetadata: IMapMessageLocalMetadata): void;
 
-    getStashedOpLocalMetadata(op: IMapOperation): unknown;
-}
+    resubmit(op: IMapOperation, localOpMetadata: IMapMessageLocalMetadata): void;
 
-export interface IMapMessageLocalMetadata {
-    lastProcessedSeq: number;
+    getStashedOpLocalMetadata(op: IMapOperation): unknown;
 }
 
 /**
@@ -121,8 +120,6 @@ export class DefaultMap<T> {
      */
     private readonly data = new Map<string, ValueTypeLocalValue<T>>();
 
-    private lastProcessedSeq: number = -1;
-
     /**
      * Create a new default map.
      * @param serializer - The serializer to serialize / parse handles
@@ -158,12 +155,9 @@ export class DefaultMap<T> {
         const iterator = {
             next(): IteratorResult<[string, any]> {
                 const nextVal = localEntriesIterator.next();
-                if (nextVal.done) {
-                    return { value: undefined, done: true };
-                } else {
-                    // Unpack the stored value
-                    return { value: [nextVal.value[0], nextVal.value[1].value], done: false };
-                }
+                return nextVal.done
+                    ? { value: undefined, done: true }
+                    : { value: [nextVal.value[0], nextVal.value[1].value], done: false }; // Unpack the stored value
             },
             [Symbol.iterator]() {
                 return this;
@@ -181,12 +175,9 @@ export class DefaultMap<T> {
         const iterator = {
             next(): IteratorResult<any> {
                 const nextVal = localValuesIterator.next();
-                if (nextVal.done) {
-                    return { value: undefined, done: true };
-                } else {
-                    // Unpack the stored value
-                    return { value: nextVal.value.value, done: false };
-                }
+                return nextVal.done
+                    ? { value: undefined, done: true }
+                    : { value: nextVal.value.value, done: false }; // Unpack the stored value
             },
             [Symbol.iterator]() {
                 return this;
@@ -217,10 +208,8 @@ export class DefaultMap<T> {
      * {@inheritDoc ISharedMap.get}
      */
     public get(key: string): T {
-        let localValue = this.data.get(key);
-        if (!this.data.has(key)) {
-            localValue = this.createCore(key, true);
-        }
+        const localValue = this.data.get(key) ?? this.createCore(key, true);
+
         return localValue.value;
     }
 
@@ -271,8 +260,14 @@ export class DefaultMap<T> {
                 continue;
             }
 
+            // Back-compat: Sequence previously arbitrarily prefixed all interval collection keys with
+            // "intervalCollections/". This would burden users trying to iterate the collection and
+            // access its value, as well as those trying to match a create message to its underlying
+            // collection. See https://github.com/microsoft/FluidFramework/issues/10557 for more context.
+            const normalizedKey = key.startsWith("intervalCollections/") ? key.substring(20) : key;
+
             const localValue = {
-                key,
+                key: normalizedKey,
                 value: this.makeLocal(key, serializable),
             };
 
@@ -292,17 +287,11 @@ export class DefaultMap<T> {
      * also sent if we are asked to resubmit the message.
      * @returns True if the operation was submitted, false otherwise.
      */
-    public trySubmitMessage(op: any, localOpMetadata: IMapMessageLocalMetadata): boolean {
+    public tryResubmitMessage(op: any, localOpMetadata: IMapMessageLocalMetadata): boolean {
         const type: string = op.type;
         const handler = this.messageHandlers.get(type);
         if (handler !== undefined) {
-            const mapLocalMetadata: Partial<IMapMessageLocalMetadata> = localOpMetadata;
-            // we don't know how to rebase these operations, so if any other op has come in
-            // we will fail.
-            if (this.lastProcessedSeq !== mapLocalMetadata?.lastProcessedSeq) {
-                throw new Error("SharedInterval does not support reconnect in presence of external changes");
-            }
-            handler.submit(op as IMapOperation);
+            handler.resubmit(op as IMapOperation, localOpMetadata);
             return true;
         }
         return false;
@@ -331,9 +320,6 @@ export class DefaultMap<T> {
         message: ISequencedDocumentMessage | undefined,
         localOpMetadata: unknown,
     ): boolean {
-        // track the seq of every incoming message, so we can detect if any
-        // changes happened during a resubmit
-        this.lastProcessedSeq = message.sequenceNumber;
         const handler = this.messageHandlers.get(op.type);
         if (handler !== undefined) {
             handler.process(op, local, message, localOpMetadata as IMapMessageLocalMetadata);
@@ -402,14 +388,26 @@ export class DefaultMap<T> {
                     const translatedValue = parseHandles(
                         op.value.value,
                         this.serializer);
-                    handler.process(previousValue, translatedValue, local, message);
+                    handler.process(previousValue, translatedValue, local, message, localOpMetadata);
                     const event: IValueChanged = { key: op.key, previousValue };
                     this.eventEmitter.emit("valueChanged", event, local, message, this.eventEmitter);
                 },
-                submit: (op: IMapValueTypeOperation) => {
+                submit: (op: IMapValueTypeOperation, localOpMetadata: IMapMessageLocalMetadata) => {
                     this.submitMessage(
                         op,
-                        { lastProcessedSeq: this.lastProcessedSeq },
+                        localOpMetadata,
+                    );
+                },
+                resubmit: (op: IMapValueTypeOperation, localOpMetadata: IMapMessageLocalMetadata) => {
+                    const localValue = this.data.get(op.key);
+                    const handler = localValue.getOpHandler(op.value.opName);
+                    const {
+                        rebasedOp,
+                        rebasedLocalOpMetadata,
+                    } = handler.rebase(localValue.value, op.value, localOpMetadata);
+                    this.submitMessage(
+                        { ...op, value: rebasedOp },
+                        rebasedLocalOpMetadata,
                     );
                 },
                 getStashedOpLocalMetadata: (op: IMapValueTypeOperation) => {
@@ -427,7 +425,7 @@ export class DefaultMap<T> {
      * @returns A value op emitter for the given key
      */
     private makeMapValueOpEmitter(key: string): IValueOpEmitter {
-        const emit = (opName: string, previousValue: any, params: any) => {
+        const emit = (opName: string, previousValue: any, params: any, localOpMetadata: IMapMessageLocalMetadata) => {
             const translatedParams = makeHandlesSerializable(
                 params,
                 this.serializer,
@@ -441,8 +439,8 @@ export class DefaultMap<T> {
                     value: translatedParams,
                 },
             };
-            // Send the localOpMetadata as undefined because we don't care about the ack.
-            this.submitMessage(op, { lastProcessedSeq: this.lastProcessedSeq });
+
+            this.submitMessage(op, localOpMetadata);
 
             const event: IValueChanged = { key, previousValue };
             this.eventEmitter.emit("valueChanged", event, true, null, this.eventEmitter);

package/src/defaultMapInterfaces.ts

@@ -24,6 +24,7 @@ export interface IValueChanged {
 
 /**
  * Value types are given an IValueOpEmitter to emit their ops through the container type that holds them.
+ * @internal
  */
 export interface IValueOpEmitter {
     /**
@@ -31,9 +32,17 @@ export interface IValueOpEmitter {
      * @param opName - Name of the emitted operation
      * @param previousValue - JSONable previous value as defined by the value type
      * @param params - JSONable params for the operation as defined by the value type
-     * @alpha
+     * @param localOpMetadata - JSONable local metadata which should be submitted with the op
+     * @internal
      */
-    emit(opName: string, previousValue: any, params: any): void;
+    emit(opName: string, previousValue: any, params: any, localOpMetadata: IMapMessageLocalMetadata): void;
+}
+
+/**
+ * @internal
+ */
+export interface IMapMessageLocalMetadata {
+    localSeq: number;
 }
 
 /**
@@ -72,14 +81,30 @@ export interface IValueOperation<T> {
      * @param params - The params on the incoming operation
      * @param local - Whether the operation originated from this client
      * @param message - The operation itself
+     * @param localOpMetadata - any local metadata submitted by `IValueOpEmitter.emit`.
      * @alpha
      */
     process(
         value: T,
         params: any,
         local: boolean,
-        message: ISequencedDocumentMessage | undefined
+        message: ISequencedDocumentMessage | undefined,
+        localOpMetadata: IMapMessageLocalMetadata | undefined
     );
+
+    /**
+     * Rebases an `op` on `value` from its original perspective (ref/local seq) to the current
+     * perspective. Should be invoked on reconnection.
+     * @param value - The current value stored at the given key, which should be the value type.
+     * @param op - The op to be rebased.
+     * @param localOpMetadata - Any local metadata that was originally submitted with the op.
+     * @returns A rebased version of the op and any local metadata that should be submitted with it.
+     */
+    rebase(
+        value: T,
+        op: IValueTypeOperationValue,
+        localOpMetadata: IMapMessageLocalMetadata
+    ): { rebasedOp: IValueTypeOperationValue; rebasedLocalOpMetadata: IMapMessageLocalMetadata; };
 }
 
 /**

package/src/index.ts

@@ -14,8 +14,11 @@ export {
     ISerializableInterval,
     ISerializedInterval,
     SequenceInterval,
+    ISerializedIntervalCollectionV2,
+    CompressedSerializedInterval,
 } from "./intervalCollection";
 export {
+    IMapMessageLocalMetadata,
     IValueOpEmitter,
 } from "./defaultMapInterfaces";
 export * from "./sharedString";