@fluidframework/map 1.2.1 → 2.0.0-internal.1.0.0

package/src/internalInterfaces.ts

@@ -0,0 +1,72 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { ISerializableValue } from "./interfaces";
+import { ILocalValue } from "./localValues";
+
+/**
+ * Operation indicating a value should be set for a key.
+ */
+ export interface IMapSetOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "set";
+
+    /**
+     * Map key being modified.
+     */
+    key: string;
+
+    /**
+     * Value to be set on the key.
+     */
+    value: ISerializableValue;
+}
+
+/**
+ * Operation indicating the map should be cleared.
+ */
+ export interface IMapClearOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "clear";
+}
+
+/**
+ * Operation indicating a key should be deleted from the map.
+ */
+ export interface IMapDeleteOperation {
+    /**
+     * String identifier of the operation type.
+     */
+    type: "delete";
+
+    /**
+     * Map key being modified.
+     */
+    key: string;
+}
+
+export interface IMapKeyEditLocalOpMetadata {
+    type: "edit";
+    pendingMessageId: number;
+    previousValue: ILocalValue;
+}
+
+export interface IMapKeyAddLocalOpMetadata {
+    type: "add";
+    pendingMessageId: number;
+}
+
+export interface IMapClearLocalOpMetadata {
+    type: "clear";
+    pendingMessageId: number;
+    previousMap?: Map<string, ILocalValue>;
+}
+
+export type MapKeyLocalOpMetadata = IMapKeyEditLocalOpMetadata | IMapKeyAddLocalOpMetadata;
+export type MapLocalOpMetadata = IMapClearLocalOpMetadata | MapKeyLocalOpMetadata;

package/src/localValues.ts

@@ -17,7 +17,7 @@ import {
 } from "./interfaces";
 
 /**
- * A local value to be stored in a container type DDS.
+ * A local value to be stored in a container type Distributed Data Store (DDS).
  */
 export interface ILocalValue {
     /**
@@ -90,8 +90,8 @@ export class PlainLocalValue implements ILocalValue {
 }
 
 /**
- * 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.
+ * Enables a container type {@link https://fluidframework.com/docs/build/dds/ | DDS} to produce and store local
+ * values with minimal awareness of how those objects are stored, serialized, and deserialized.
  */
 export class LocalValueMaker {
     /**

package/src/map.ts

@@ -33,7 +33,8 @@ interface IMapSerializationFormat {
 const snapshotFileName = "header";
 
 /**
- * The factory that defines the map.
+ * {@link @fluidframework/datastore-definitions#IChannelFactory} for {@link SharedMap}.
+ *
  * @sealed
  */
 export class MapFactory implements IChannelFactory {
@@ -91,10 +92,7 @@ export class MapFactory implements IChannelFactory {
 }
 
 /**
- * The SharedMap distributed data structure can be used to store key-value pairs. It provides the same API for setting
- * and retrieving values that JavaScript developers are accustomed to with the
- * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Map | Map} built-in object.
- * However, the keys of a SharedMap must be strings.
+ * {@inheritDoc ISharedMap}
  */
 export class SharedMap extends SharedObject<ISharedMapEvents> implements ISharedMap {
     /**
@@ -340,7 +338,7 @@ export class SharedMap extends SharedObject<ISharedMapEvents> implements IShared
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.onDisconnect}
      * @internal
      */
-    protected onDisconnect() {}
+    protected onDisconnect() { }
 
     /**
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.reSubmitCore}
@@ -355,8 +353,7 @@ export class SharedMap extends SharedObject<ISharedMapEvents> implements IShared
      * @internal
      */
     protected applyStashedOp(content: any): unknown {
-        this.kernel.tryProcessMessage(content, false, undefined);
-        return this.kernel.tryGetStashedOpLocalMetadata(content);
+        return this.kernel.tryApplyStashedOp(content);
     }
 
     /**
@@ -373,7 +370,7 @@ export class SharedMap extends SharedObject<ISharedMapEvents> implements IShared
      * {@inheritDoc @fluidframework/shared-object-base#SharedObject.rollback}
      * @internal
     */
-   protected rollback(content: any, localOpMetadata: unknown) {
-       this.kernel.rollback(content, localOpMetadata);
-   }
+    protected rollback(content: any, localOpMetadata: unknown) {
+        this.kernel.rollback(content, localOpMetadata);
+    }
 }

package/src/mapKernel.ts

@@ -11,6 +11,14 @@ import {
     ISerializedValue,
     ISharedMapEvents,
 } from "./interfaces";
+import {
+    IMapSetOperation,
+    IMapDeleteOperation,
+    IMapClearOperation,
+    IMapKeyEditLocalOpMetadata,
+    IMapKeyAddLocalOpMetadata,
+    IMapClearLocalOpMetadata,
+} from "./internalInterfaces";
 import {
     ILocalValue,
     LocalValueMaker,
@@ -31,7 +39,7 @@ interface IMapMessageHandler {
     process(
         op: IMapOperation,
         local: boolean,
-        localOpMetadata: unknown,
+        localOpMetadata: MapLocalOpMetadata,
     ): void;
 
     /**
@@ -39,44 +47,9 @@ interface IMapMessageHandler {
      * @param op - The map operation to submit
      * @param localOpMetadata - The metadata to be submitted with the message.
      */
-    submit(op: IMapOperation, localOpMetadata: unknown): void;
-
-    getStashedOpLocalMetadata(op: IMapOperation): unknown;
-}
-
-/**
- * Operation indicating a value should be set for a key.
- */
-export interface IMapSetOperation {
-    /**
-     * String identifier of the operation type.
-     */
-    type: "set";
-
-    /**
-     * Map key being modified.
-     */
-    key: string;
+    submit(op: IMapOperation, localOpMetadata: MapLocalOpMetadata): void;
 
-    /**
-     * Value to be set on the key.
-     */
-    value: ISerializableValue;
-}
-
-/**
- * Operation indicating a key should be deleted from the map.
- */
-export interface IMapDeleteOperation {
-    /**
-     * String identifier of the operation type.
-     */
-    type: "delete";
-
-    /**
-     * Map key being modified.
-     */
-    key: string;
+    applyStashedOp(op: IMapOperation): MapLocalOpMetadata;
 }
 
 /**
@@ -84,16 +57,6 @@ export interface IMapDeleteOperation {
  */
 export type IMapKeyOperation = IMapSetOperation | IMapDeleteOperation;
 
-/**
- * Operation indicating the map should be cleared.
- */
-export interface IMapClearOperation {
-    /**
-     * String identifier of the operation type.
-     */
-    type: "clear";
-}
-
 /**
  * Description of a map delta operation
  */
@@ -101,33 +64,23 @@ export type IMapOperation = IMapKeyOperation | IMapClearOperation;
 
 /**
  * Defines the in-memory object structure to be used for the conversion to/from serialized.
- * Directly used in JSON.stringify, direct result from JSON.parse
+ *
+ * @remarks Directly used in
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/stringify
+ * | JSON.stringify}, direct result from
+ * {@link https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/JSON/parse | JSON.parse}.
  */
 export interface IMapDataObjectSerializable {
     [key: string]: ISerializableValue;
 }
 
+/**
+ * Serialized key/value data.
+ */
 export interface IMapDataObjectSerialized {
     [key: string]: ISerializedValue;
 }
 
-interface IMapKeyEditLocalOpMetadata {
-    type: "edit";
-    pendingMessageId: number;
-    previousValue?: ILocalValue;
-}
-
-interface IMapKeyAddLocalOpMetadata {
-    type: "add";
-    pendingMessageId: number;
-}
-
-interface IMapClearLocalOpMetadata {
-    type: "clear";
-    pendingMessageId: number;
-    previousMap?: Map<string, ILocalValue>;
-}
-
 type MapKeyLocalOpMetadata = IMapKeyEditLocalOpMetadata | IMapKeyAddLocalOpMetadata;
 type MapLocalOpMetadata = IMapClearLocalOpMetadata | MapKeyLocalOpMetadata;
 
@@ -145,6 +98,23 @@ function isMapLocalOpMetadata(metadata: any): metadata is MapLocalOpMetadata {
         (metadata.type === "add" || metadata.type === "edit" || metadata.type === "clear");
 }
 
+function createClearLocalOpMetadata(op: IMapClearOperation,
+    pendingClearMessageId: number, previousMap?: Map<string, ILocalValue>): IMapClearLocalOpMetadata {
+    const localMetadata: IMapClearLocalOpMetadata = {
+        type: "clear",
+        pendingMessageId: pendingClearMessageId, previousMap,
+    };
+    return localMetadata;
+}
+
+function createKeyLocalOpMetadata(op: IMapKeyOperation,
+    pendingMessageId: number, previousValue?: ILocalValue): MapKeyLocalOpMetadata {
+    const localMetadata: MapKeyLocalOpMetadata = previousValue ?
+        { type: "edit", pendingMessageId, previousValue } :
+        { type: "add", pendingMessageId };
+    return localMetadata;
+}
+
 /**
  * A SharedMap is a map-like distributed data structure.
  */
@@ -431,16 +401,16 @@ export class MapKernel {
         if (handler === undefined) {
             return false;
         }
-        handler.submit(op as IMapOperation, localOpMetadata);
+        handler.submit(op as IMapOperation, localOpMetadata as MapLocalOpMetadata);
         return true;
     }
 
-    public tryGetStashedOpLocalMetadata(op: any): unknown {
+    public tryApplyStashedOp(op: any): unknown {
         const handler = this.messageHandlers.get(op.type);
         if (handler === undefined) {
             throw new Error("no apply stashed op handler");
         }
-        return handler.getStashedOpLocalMetadata(op as IMapOperation);
+        return handler.applyStashedOp(op as IMapOperation);
     }
 
     /**
@@ -460,7 +430,7 @@ export class MapKernel {
         if (handler === undefined) {
             return false;
         }
-        handler.process(op, local, localOpMetadata);
+        handler.process(op, local, localOpMetadata as MapLocalOpMetadata);
         return true;
     }
 
@@ -595,7 +565,7 @@ export class MapKernel {
     private needProcessKeyOperation(
         op: IMapKeyOperation,
         local: boolean,
-        localOpMetadata: unknown,
+        localOpMetadata: MapLocalOpMetadata,
     ): boolean {
         if (this.pendingClearMessageIds.length > 0) {
             if (local) {
@@ -653,7 +623,7 @@ export class MapKernel {
                     }
                     this.clearCore(local);
                 },
-                submit: (op: IMapClearOperation, localOpMetadata: unknown) => {
+                submit: (op: IMapClearOperation, localOpMetadata: IMapClearLocalOpMetadata) => {
                     assert(isClearLocalOpMetadata(localOpMetadata), 0x2fc /* Invalid localOpMetadata for clear */);
                     // We don't reuse the metadata pendingMessageId but send a new one on each submit.
                     const pendingClearMessageId = this.pendingClearMessageIds.shift();
@@ -661,9 +631,11 @@ export class MapKernel {
                         0x2fd /* pendingMessageId does not match */);
                     this.submitMapClearMessage(op, localOpMetadata.previousMap);
                 },
-                getStashedOpLocalMetadata: (op: IMapClearOperation) => {
+                applyStashedOp: (op: IMapClearOperation) => {
+                    const copy = new Map<string, ILocalValue>(this.data);
+                    this.clearCore(true);
                     // We don't reuse the metadata pendingMessageId but send a new one on each submit.
-                    return { type: "clear", pendingMessageId: this.getMapClearMessageId() };
+                    return createClearLocalOpMetadata(op, this.getMapClearMessageId(), copy);
                 },
             });
         messageHandlers.set(
@@ -675,12 +647,13 @@ export class MapKernel {
                     }
                     this.deleteCore(op.key, local);
                 },
-                submit: (op: IMapDeleteOperation, localOpMetadata: unknown) => {
+                submit: (op: IMapDeleteOperation, localOpMetadata: MapKeyLocalOpMetadata) => {
                     this.resubmitMapKeyMessage(op, localOpMetadata);
                 },
-                getStashedOpLocalMetadata: (op: IMapDeleteOperation) => {
+                applyStashedOp: (op: IMapDeleteOperation) => {
                     // We don't reuse the metadata pendingMessageId but send a new one on each submit.
-                    return { type: "edit", pendingMessageId: this.getMapKeyMessageId(op) };
+                    const previousValue = this.deleteCore(op.key, true);
+                    return createKeyLocalOpMetadata(op, this.getMapKeyMessageId(op), previousValue);
                 },
             });
         messageHandlers.set(
@@ -695,12 +668,14 @@ export class MapKernel {
                     const context = this.makeLocal(op.key, op.value);
                     this.setCore(op.key, context, local);
                 },
-                submit: (op: IMapSetOperation, localOpMetadata: unknown) => {
+                submit: (op: IMapSetOperation, localOpMetadata: MapKeyLocalOpMetadata) => {
                     this.resubmitMapKeyMessage(op, localOpMetadata);
                 },
-                getStashedOpLocalMetadata: (op: IMapSetOperation) => {
+                applyStashedOp: (op: IMapSetOperation) => {
                     // We don't reuse the metadata pendingMessageId but send a new one on each submit.
-                    return { type: "edit", pendingMessageId: this.getMapKeyMessageId(op) };
+                    const context = this.makeLocal(op.key, op.value);
+                    const previousValue = this.setCore(op.key, context, true);
+                    return createKeyLocalOpMetadata(op, this.getMapKeyMessageId(op), previousValue);
                 },
             });
 
@@ -718,7 +693,7 @@ export class MapKernel {
      * @param op - The clear message
      */
     private submitMapClearMessage(op: IMapClearOperation, previousMap?: Map<string, ILocalValue>): void {
-        const metadata = { type: "clear", pendingMessageId: this.getMapClearMessageId(), previousMap };
+        const metadata = createClearLocalOpMetadata(op, this.getMapClearMessageId(), previousMap);
         this.submitMessage(op, metadata);
     }
 
@@ -739,10 +714,7 @@ export class MapKernel {
      * @param previousValue - The value of the key before this op
      */
     private submitMapKeyMessage(op: IMapKeyOperation, previousValue?: ILocalValue): void {
-        const pendingMessageId = this.getMapKeyMessageId(op);
-        const localMetadata = previousValue ?
-            { type: "edit", pendingMessageId, previousValue } :
-            { type: "add", pendingMessageId };
+        const localMetadata = createKeyLocalOpMetadata(op, this.getMapKeyMessageId(op), previousValue);
         this.submitMessage(op, localMetadata);
     }
 
@@ -751,7 +723,7 @@ export class MapKernel {
      * @param op - The map key message
      * @param localOpMetadata - Metadata from the previous submit
      */
-    private resubmitMapKeyMessage(op: IMapKeyOperation, localOpMetadata: unknown): void {
+    private resubmitMapKeyMessage(op: IMapKeyOperation, localOpMetadata: MapLocalOpMetadata): void {
         assert(isMapKeyLocalOpMetadata(localOpMetadata), 0x2fe /* Invalid localOpMetadata in submit */);
 
         // clear the old pending message id

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/map";
-export const pkgVersion = "1.2.1";
+export const pkgVersion = "2.0.0-internal.1.0.0";