@fluidframework/sequence 0.59.3002 → 0.59.4000-71130

package/src/intervalCollection.ts

@@ -28,7 +28,7 @@ import {
 } from "@fluidframework/merge-tree";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { v4 as uuid } from "uuid";
-import { IValueFactory, IValueOpEmitter, IValueOperation, IValueType } from "./mapKernelInterfaces";
+import { IValueFactory, IValueOpEmitter, IValueOperation, IValueType } from "./defaultMapInterfaces";
 
 const reservedIntervalIdKey = "intervalId";
 
@@ -684,12 +684,7 @@ export class SequenceIntervalCollectionValueType
                 "add",
                 {
                     process: (value, params, local, op) => {
-                        // Local ops were applied when the message was created
-                        if (local) {
-                            return;
-                        }
-
-                        value.addInternal(params, local, op);
+                        value.ackAdd(params, local, op);
                     },
                 },
             ],
@@ -697,10 +692,7 @@ export class SequenceIntervalCollectionValueType
                 "delete",
                 {
                     process: (value, params, local, op) => {
-                        if (local) {
-                            return;
-                        }
-                        value.deleteInterval(params, local, op);
+                        value.ackDelete(params, local, op);
                     },
                 },
             ],
@@ -708,7 +700,7 @@ export class SequenceIntervalCollectionValueType
                 "change",
                 {
                     process: (value, params, local, op) => {
-                        value.changeInterval(params, local, op);
+                        value.ackChange(params, local, op);
                     },
                 },
             ]]);
@@ -767,12 +759,7 @@ export class IntervalCollectionValueType
                 "add",
                 {
                     process: (value, params, local, op) => {
-                        // Local ops were applied when the message was created
-                        if (local) {
-                            return;
-                        }
-
-                        value.addInternal(params, local, op);
+                        value.ackAdd(params, local, op);
                     },
                 },
             ],
@@ -780,10 +767,7 @@ export class IntervalCollectionValueType
                 "delete",
                 {
                     process: (value, params, local, op) => {
-                        if (local) {
-                            return;
-                        }
-                        value.deleteInterval(params, local, op);
+                        value.ackDelete(params, local, op);
                     },
                 },
             ],
@@ -791,7 +775,7 @@ export class IntervalCollectionValueType
                 "change",
                 {
                     process: (value, params, local, op) => {
-                        value.changeInterval(params, local, op);
+                        value.ackChange(params, local, op);
                     },
                 },
             ]]);
@@ -842,8 +826,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
     private localCollection: LocalIntervalCollection<TInterval>;
     private onDeserialize: DeserializeCallback;
     private client: Client;
-    private pendingChangeStart: Map<string, ISerializedInterval[]>;
-    private pendingChangeEnd: Map<string, ISerializedInterval[]>;
+    private pendingChangesStart: Map<string, ISerializedInterval[]>;
+    private pendingChangesEnd: Map<string, ISerializedInterval[]>;
 
     public get attached(): boolean {
         return !!this.localCollection;
@@ -998,16 +982,16 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
 
     private addPendingChange(id: string, serializedInterval: ISerializedInterval) {
         if (serializedInterval.start !== undefined) {
-            if (!this.pendingChangeStart) {
-                this.pendingChangeStart = new Map<string, ISerializedInterval[]>();
+            if (!this.pendingChangesStart) {
+                this.pendingChangesStart = new Map<string, ISerializedInterval[]>();
             }
-            this.addPendingChangeHelper(id, this.pendingChangeStart, serializedInterval);
+            this.addPendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
         }
         if (serializedInterval.end !== undefined) {
-            if (!this.pendingChangeEnd) {
-                this.pendingChangeEnd = new Map<string, ISerializedInterval[]>();
+            if (!this.pendingChangesEnd) {
+                this.pendingChangesEnd = new Map<string, ISerializedInterval[]>();
             }
-            this.addPendingChangeHelper(id, this.pendingChangeEnd, serializedInterval);
+            this.addPendingChangeHelper(id, this.pendingChangesEnd, serializedInterval);
         }
     }
 
@@ -1028,10 +1012,10 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         // Change ops always have an ID.
         const id: string = serializedInterval.properties[reservedIntervalIdKey];
         if (serializedInterval.start !== undefined) {
-            this.removePendingChangeHelper(id, this.pendingChangeStart, serializedInterval);
+            this.removePendingChangeHelper(id, this.pendingChangesStart, serializedInterval);
         }
         if (serializedInterval.end !== undefined) {
-            this.removePendingChangeHelper(id, this.pendingChangeEnd, serializedInterval);
+            this.removePendingChangeHelper(id, this.pendingChangesEnd, serializedInterval);
         }
     }
 
@@ -1054,16 +1038,22 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
     }
 
     private hasPendingChangeStart(id: string) {
-        const entries = this.pendingChangeStart?.get(id);
+        const entries = this.pendingChangesStart?.get(id);
         return entries && entries.length !== 0;
     }
 
     private hasPendingChangeEnd(id: string) {
-        const entries = this.pendingChangeEnd?.get(id);
+        const entries = this.pendingChangesEnd?.get(id);
         return entries && entries.length !== 0;
     }
 
+    /** @deprecated - use ackChange */
     public changeInterval(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage) {
+        return this.ackChange(serializedInterval, local, op);
+    }
+
+    /** @internal */
+    public ackChange(serializedInterval: ISerializedInterval, local: boolean, op: ISequencedDocumentMessage) {
         if (!this.attached) {
             throw new Error("Attach must be called before accessing intervals");
         }
@@ -1140,10 +1130,25 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         });
     }
 
+    /** @deprecated - use ackAdd */
     public addInternal(
         serializedInterval: ISerializedInterval,
         local: boolean,
         op: ISequencedDocumentMessage) {
+        return this.ackAdd(serializedInterval, local, op);
+    }
+
+    /** @internal */
+    public ackAdd(
+        serializedInterval: ISerializedInterval,
+        local: boolean,
+        op: ISequencedDocumentMessage) {
+        if (local) {
+            // Local ops were applied when the message was created and there's no "pending add"
+            // state to bookkeep
+            return;
+        }
+
         if (!this.attached) {
             throw new Error("attachSequence must be called");
         }
@@ -1158,14 +1163,8 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
             op);
 
         if (interval) {
-            // Local ops get submitted to the server. Remote ops have the deserializer run.
-            if (local) {
-                // Review: Is this case possible?
-                this.emitter.emit("add", undefined, serializedInterval);
-            } else {
-                if (this.onDeserialize) {
-                    this.onDeserialize(interval);
-                }
+            if (this.onDeserialize) {
+                this.onDeserialize(interval);
             }
         }
 
@@ -1174,10 +1173,26 @@ export class IntervalCollection<TInterval extends ISerializableInterval>
         return interval;
     }
 
+    /** @deprecated - use ackDelete */
     public deleteInterval(
         serializedInterval: ISerializedInterval,
         local: boolean,
         op: ISequencedDocumentMessage): void {
+        return this.ackDelete(serializedInterval, local, op);
+    }
+
+    /** @internal */
+    public ackDelete(
+        serializedInterval: ISerializedInterval,
+        local: boolean,
+        op: ISequencedDocumentMessage): void {
+        if (local) {
+            // Local ops were applied when the message was created and there's no "pending delete"
+            // state to bookkeep: remote operation application takes into account possibility of
+            // locally deleted interval whenever a lookup happens.
+            return;
+        }
+
         if (!this.attached) {
             throw new Error("attach must be called prior to deleting intervals");
         }

package/src/localValues.ts

@@ -6,23 +6,19 @@
 import { IFluidHandle } from "@fluidframework/core-interfaces";
 import {
     IFluidSerializer,
-    ISerializedHandle,
-    parseHandles,
     serializeHandles,
-    ValueType,
 } from "@fluidframework/shared-object-base";
 import {
     ISerializableValue,
     ISerializedValue,
-    IValueOpEmitter,
     IValueOperation,
     IValueType,
-} from "./mapKernelInterfaces";
+} from "./defaultMapInterfaces";
 
 /**
  * A local value to be stored in a container type DDS.
  */
-export interface ILocalValue {
+export interface ILocalValue<T = any> {
     /**
      * Type indicator of the value stored within.
      */
@@ -31,7 +27,7 @@ export interface ILocalValue {
     /**
      * The in-memory value stored within.
      */
-    readonly value: any;
+    readonly value: T;
 
     /**
      * Retrieve the serialized form of the value stored within.
@@ -56,57 +52,18 @@ export function makeSerializable(
     };
 }
 
-/**
- * Manages a contained plain value.  May also contain shared object handles.
- */
-export class PlainLocalValue implements ILocalValue {
-    /**
-     * Create a new PlainLocalValue.
-     * @param value - The value to store, which may contain shared object handles
-     */
-    constructor(public readonly value: any) {
-    }
-
-    /**
-     * {@inheritDoc ILocalValue."type"}
-     */
-    public get type(): string {
-        return ValueType[ValueType.Plain];
-    }
-
-    /**
-     * {@inheritDoc ILocalValue.makeSerialized}
-     */
-    public makeSerialized(
-        serializer: IFluidSerializer,
-        bind: IFluidHandle,
-    ): ISerializedValue {
-        // Stringify to convert to the serialized handle values - and then parse in order to create
-        // a POJO for the op
-        const value = serializeHandles(this.value, serializer, bind);
-
-        return {
-            type: this.type,
-            value,
-        };
-    }
-}
-
 /**
  * Manages a contained value type.
  *
- * @privateRemarks
- * TODO: Should maybe be a generic
- *
  * @alpha
  */
-export class ValueTypeLocalValue implements ILocalValue {
+export class ValueTypeLocalValue<T> implements ILocalValue<T> {
     /**
      * Create a new ValueTypeLocalValue.
      * @param value - The instance of the value type stored within
      * @param valueType - The type object of the value type stored within
      */
-    constructor(public readonly value: any, private readonly valueType: IValueType<any>) {
+    constructor(public readonly value: T, private readonly valueType: IValueType<T>) {
     }
 
     /**
@@ -137,7 +94,7 @@ export class ValueTypeLocalValue implements ILocalValue {
      * @param opName - The name of the operation that needs processing
      * @returns The object which can process the given op
      */
-    public getOpHandler(opName: string): IValueOperation<any> {
+    public getOpHandler(opName: string): IValueOperation<T> {
         const handler = this.valueType.ops.get(opName);
         if (!handler) {
             throw new Error("Unknown type message");
@@ -146,108 +103,3 @@ export class ValueTypeLocalValue implements ILocalValue {
         return handler;
     }
 }
-
-/**
- * A LocalValueMaker enables a container type DDS to produce and store local values with minimal awareness of how
- * those objects are stored, serialized, and deserialized.
- */
-export class LocalValueMaker {
-    /**
-     * The value types this maker is able to produce.
-     */
-    private readonly valueTypes = new Map<string, IValueType<any>>();
-
-    /**
-     * Create a new LocalValueMaker.
-     * @param serializer - The serializer to serialize / parse handles.
-     */
-    constructor(private readonly serializer: IFluidSerializer) {
-    }
-
-    /**
-     * Register a value type this maker will be able to produce.
-     * @param type - The value type to register
-     * @alpha
-     */
-    public registerValueType<T>(type: IValueType<T>) {
-        this.valueTypes.set(type.name, type);
-    }
-
-    /**
-     * Create a new local value from an incoming serialized value.
-     * @param serializable - The serializable value to make local
-     */
-    public fromSerializable(serializable: ISerializableValue): ILocalValue {
-        // Migrate from old shared value to handles
-        if (serializable.type === ValueType[ValueType.Shared]) {
-            serializable.type = ValueType[ValueType.Plain];
-            const handle: ISerializedHandle = {
-                type: "__fluid_handle__",
-                url: serializable.value as string,
-            };
-            serializable.value = handle;
-        }
-
-        const translatedValue = parseHandles(serializable.value, this.serializer);
-
-        return new PlainLocalValue(translatedValue);
-    }
-
-    /**
-     * Create a new local value from an incoming serialized value for value type
-     * @param serializable - The serializable value to make local
-     * @param emitter - The value op emitter, if the serializable is a value type
-     */
-    public fromSerializableValueType(serializable: ISerializableValue, emitter: IValueOpEmitter): ILocalValue {
-        if (this.valueTypes.has(serializable.type)) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            const valueType = this.valueTypes.get(serializable.type)!;
-
-            serializable.value = parseHandles(serializable.value, this.serializer);
-
-            const localValue = valueType.factory.load(emitter, serializable.value);
-            return new ValueTypeLocalValue(localValue, valueType);
-        } else {
-            throw new Error(`Unknown value type "${serializable.type}"`);
-        }
-    }
-
-    /**
-     * Create a new local value containing a given plain object.
-     * @param value - The value to store
-     * @returns An ILocalValue containing the value
-     */
-    public fromInMemory(value: any): ILocalValue {
-        return new PlainLocalValue(value);
-    }
-
-    /**
-     * Create a new local value containing a value type.
-     * @param type - The type of the value type to create
-     * @param emitter - The IValueOpEmitter object that the new value type will use to emit ops
-     * @param params - The initialization arguments for the value type
-     * @returns An ILocalValue containing the new value type
-     * @alpha
-     */
-    public makeValueType(type: string, emitter: IValueOpEmitter, params: any): ILocalValue {
-        const valueType = this.loadValueType(params, type, emitter);
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        return new ValueTypeLocalValue(valueType, this.valueTypes.get(type)!);
-    }
-
-    /**
-     * Create a new value type.
-     * @param params - The initialization arguments for the value type
-     * @param type - The type of value type to create
-     * @param emitter - The IValueOpEmitter object that the new value type will use to emit ops
-     * @returns The new value type
-     * @alpha
-     */
-    private loadValueType(params: any, type: string, emitter: IValueOpEmitter): any {
-        const valueType = this.valueTypes.get(type);
-        if (!valueType) {
-            throw new Error(`Unknown type '${type}' specified`);
-        }
-        return valueType.factory.load(emitter, params);
-    }
-}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/sequence";
-export const pkgVersion = "0.59.3002";
+export const pkgVersion = "0.59.4000-71130";

package/src/sequence.ts

@@ -55,8 +55,8 @@ import {
     SequenceInterval,
     SequenceIntervalCollectionValueType,
 } from "./intervalCollection";
-import { MapKernel } from "./mapKernel";
-import { IValueChanged } from "./mapKernelInterfaces";
+import { IMapMessageLocalMetadata, DefaultMap } from "./defaultMap";
+import { IValueChanged } from "./defaultMapInterfaces";
 import { SequenceDeltaEvent, SequenceMaintenanceEvent } from "./sequenceDeltaEvent";
 import { ISharedIntervalCollection } from "./sharedIntervalCollection";
 
@@ -166,7 +166,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
     private readonly loadedDeferredIncomingOps: ISequencedDocumentMessage[] = [];
 
     private messagesSinceMSNChange: ISequencedDocumentMessage[] = [];
-    private readonly intervalMapKernel: MapKernel;
+    private readonly intervalCollections: DefaultMap<IntervalCollection<SequenceInterval>>;
     constructor(
         private readonly dataStoreRuntime: IFluidDataStoreRuntime,
         public id: string,
@@ -220,12 +220,12 @@ export abstract class SharedSegmentSequence<T extends ISegment>
             }
         });
 
-        this.intervalMapKernel = new MapKernel(
+        this.intervalCollections = new DefaultMap(
             this.serializer,
             this.handle,
             (op, localOpMetadata) => this.submitLocalMessage(op, localOpMetadata),
-            () => this.isAttached(),
-            [new SequenceIntervalCollectionValueType()]);
+            new SequenceIntervalCollectionValueType(),
+        );
     }
 
     /**
@@ -435,25 +435,19 @@ export abstract class SharedSegmentSequence<T extends ISegment>
         }
     }
 
+    /**
+     * @deprecated - IntervalCollections are created on a first-write wins basis, and concurrent creates
+     * are supported. Use `getIntervalCollection` instead.
+     */
     public async waitIntervalCollection(
         label: string,
     ): Promise<IntervalCollection<SequenceInterval>> {
-        return this.intervalMapKernel.wait<IntervalCollection<SequenceInterval>>(
-            this.getIntervalCollectionPath(label));
+        return this.intervalCollections.get(this.getIntervalCollectionPath(label));
     }
 
-    // TODO: fix race condition on creation by putting type on every operation
     public getIntervalCollection(label: string): IntervalCollection<SequenceInterval> {
         const labelPath = this.getIntervalCollectionPath(label);
-        if (!this.intervalMapKernel.has(labelPath)) {
-            this.intervalMapKernel.createValueType(
-                labelPath,
-                SequenceIntervalCollectionValueType.Name,
-                undefined);
-        }
-
-        const sharedCollection =
-            this.intervalMapKernel.get<IntervalCollection<SequenceInterval>>(labelPath);
+        const sharedCollection = this.intervalCollections.get(labelPath);
         return sharedCollection;
     }
 
@@ -466,7 +460,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
      *     ...
     */
     public getIntervalCollectionLabels(): IterableIterator<string> {
-        return this.intervalMapKernel.keys();
+        return this.intervalCollections.keys();
     }
 
     protected summarizeCore(serializer: IFluidSerializer): ISummaryTreeWithStats {
@@ -474,8 +468,8 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 
         // conditionally write the interval collection blob
         // only if it has entries
-        if (this.intervalMapKernel.size > 0) {
-            builder.addBlob(snapshotFileName, this.intervalMapKernel.serialize(serializer));
+        if (this.intervalCollections.size > 0) {
+            builder.addBlob(snapshotFileName, this.intervalCollections.serialize(serializer));
         }
 
         builder.addWithStats(contentPath, this.summarizeMergeTree(serializer));
@@ -488,8 +482,8 @@ export abstract class SharedSegmentSequence<T extends ISegment>
      * All the IFluidHandle's represent routes to other objects.
      */
     protected processGCDataCore(serializer: SummarySerializer) {
-        if (this.intervalMapKernel.size > 0) {
-            this.intervalMapKernel.serialize(serializer);
+        if (this.intervalCollections.size > 0) {
+            this.intervalCollections.serialize(serializer);
         }
 
         this.client.serializeGCData(this.handle, serializer);
@@ -528,7 +522,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
     protected onDisconnect() {}
 
     protected reSubmitCore(content: any, localOpMetadata: unknown) {
-        if (!this.intervalMapKernel.trySubmitMessage(content, localOpMetadata)) {
+        if (!this.intervalCollections.trySubmitMessage(content, localOpMetadata as IMapMessageLocalMetadata)) {
             this.submitSequenceMessage(
                 this.client.regeneratePendingOp(
                     content as IMergeTreeOp,
@@ -543,7 +537,7 @@ export abstract class SharedSegmentSequence<T extends ISegment>
         if (await storage.contains(snapshotFileName)) {
             const blob = await storage.readBlob(snapshotFileName);
             const header = bufferToString(blob, "utf8");
-            this.intervalMapKernel.populate(header);
+            this.intervalCollections.populate(header);
         }
 
         try {
@@ -604,7 +598,12 @@ export abstract class SharedSegmentSequence<T extends ISegment>
         } else {
             assert(message.type === MessageType.Operation, 0x073 /* "Sequence message not operation" */);
 
-            const handled = this.intervalMapKernel.tryProcessMessage(message.contents, local, message, localOpMetadata);
+            const handled = this.intervalCollections.tryProcessMessage(
+                message.contents,
+                local,
+                message,
+                localOpMetadata,
+            );
 
             if (!handled) {
                 this.processMergeTreeMsg(message, local);
@@ -728,18 +727,18 @@ export abstract class SharedSegmentSequence<T extends ISegment>
 
     private initializeIntervalCollections() {
         // Listen and initialize new SharedIntervalCollections
-        this.intervalMapKernel.eventEmitter.on("create", (ev: IValueChanged, local: boolean) => {
-            const intervalCollection = this.intervalMapKernel.get<IntervalCollection<SequenceInterval>>(ev.key);
+        this.intervalCollections.eventEmitter.on("create", ({ key, previousValue }: IValueChanged, local: boolean) => {
+            const intervalCollection = this.intervalCollections.get(key);
             if (!intervalCollection.attached) {
-                intervalCollection.attachGraph(this.client, ev.key);
+                intervalCollection.attachGraph(this.client, key);
             }
-            assert(ev.previousValue === undefined, 0x2c1 /* "Creating an interval that already exists?" */);
-            this.emit("createIntervalCollection", ev.key, local, this);
+            assert(previousValue === undefined, 0x2c1 /* "Creating an interval collection that already exists?" */);
+            this.emit("createIntervalCollection", key, local, this);
         });
 
         // Initialize existing SharedIntervalCollections
-        for (const key of this.intervalMapKernel.keys()) {
-            const intervalCollection = this.intervalMapKernel.get<IntervalCollection<SequenceInterval>>(key);
+        for (const key of this.intervalCollections.keys()) {
+            const intervalCollection = this.intervalCollections.get(key);
             intervalCollection.attachGraph(this.client, key);
         }
     }