@fluidframework/sequence 0.59.3003 → 0.59.4000

package/lib/mapKernel.js

@@ -1,595 +0,0 @@
-/*!
- * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
- * Licensed under the MIT License.
- */
-import { makeHandlesSerializable, parseHandles, ValueType } from "@fluidframework/shared-object-base";
-import { assert, TypedEventEmitter } from "@fluidframework/common-utils";
-import { LocalValueMaker, makeSerializable, } from "./localValues";
-/**
- * A SharedMap is a map-like distributed data structure.
- */
-export class MapKernel {
-    /**
-     * Create a new shared map kernel.
-     * @param serializer - The serializer to serialize / parse handles
-     * @param handle - The handle of the shared object using the kernel
-     * @param submitMessage - A callback to submit a message through the shared object
-     * @param isAttached - To query whether the shared object should generate ops
-     * @param valueTypes - The value types to register
-     * @param eventEmitter - The object that will emit map events
-     */
-    constructor(serializer, handle, submitMessage, isAttached, valueTypes, eventEmitter = new TypedEventEmitter()) {
-        this.serializer = serializer;
-        this.handle = handle;
-        this.submitMessage = submitMessage;
-        this.isAttached = isAttached;
-        this.eventEmitter = eventEmitter;
-        /**
-         * Mapping of op types to message handlers.
-         */
-        this.messageHandlers = new Map();
-        /**
-         * The in-memory data the map is storing.
-         */
-        this.data = new Map();
-        /**
-         * Keys that have been modified locally but not yet ack'd from the server.
-         */
-        this.pendingKeys = new Map();
-        /**
-         * This is used to assign a unique id to every outgoing operation and helps in tracking unacked ops.
-         */
-        this.pendingMessageId = -1;
-        /**
-         * If a clear has been performed locally but not yet ack'd from the server, then this stores the pending id
-         * of that clear operation. Otherwise, is -1.
-         */
-        this.pendingClearMessageId = -1;
-        this.lastProcessedSeq = -1;
-        this.localValueMaker = new LocalValueMaker(serializer);
-        this.messageHandlers = this.getMessageHandlers();
-        for (const type of valueTypes) {
-            this.localValueMaker.registerValueType(type);
-        }
-    }
-    /**
-     * The number of key/value pairs stored in the map.
-     */
-    get size() {
-        return this.data.size;
-    }
-    /**
-     * Get an iterator over the keys in this map.
-     * @returns The iterator
-     */
-    keys() {
-        return this.data.keys();
-    }
-    /**
-     * Get an iterator over the entries in this map.
-     * @returns The iterator
-     */
-    entries() {
-        const localEntriesIterator = this.data.entries();
-        const iterator = {
-            next() {
-                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 };
-                }
-            },
-            [Symbol.iterator]() {
-                return this;
-            },
-        };
-        return iterator;
-    }
-    /**
-     * Get an iterator over the values in this map.
-     * @returns The iterator
-     */
-    values() {
-        const localValuesIterator = this.data.values();
-        const iterator = {
-            next() {
-                const nextVal = localValuesIterator.next();
-                if (nextVal.done) {
-                    return { value: undefined, done: true };
-                }
-                else {
-                    // Unpack the stored value
-                    return { value: nextVal.value.value, done: false };
-                }
-            },
-            [Symbol.iterator]() {
-                return this;
-            },
-        };
-        return iterator;
-    }
-    /**
-     * Get an iterator over the entries in this map.
-     * @returns The iterator
-     */
-    [Symbol.iterator]() {
-        return this.entries();
-    }
-    /**
-     * Executes the given callback on each entry in the map.
-     * @param callbackFn - Callback function
-     */
-    forEach(callbackFn) {
-        this.data.forEach((localValue, key, m) => {
-            callbackFn(localValue.value, key, m);
-        });
-    }
-    /**
-     * {@inheritDoc ISharedMap.get}
-     */
-    get(key) {
-        if (!this.data.has(key)) {
-            return undefined;
-        }
-        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-        const localValue = this.data.get(key);
-        return localValue.value;
-    }
-    /**
-     * {@inheritDoc ISharedMap.wait}
-     */
-    async wait(key) {
-        // Return immediately if the value already exists
-        if (this.has(key)) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            return this.get(key);
-        }
-        // Otherwise subscribe to changes
-        return new Promise((resolve) => {
-            const callback = (changed) => {
-                if (key === changed.key) {
-                    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-                    resolve(this.get(changed.key));
-                    this.eventEmitter.removeListener("create", callback);
-                }
-            };
-            this.eventEmitter.on("create", callback);
-        });
-    }
-    /**
-     * Check if a key exists in the map.
-     * @param key - The key to check
-     * @returns True if the key exists, false otherwise
-     */
-    has(key) {
-        return this.data.has(key);
-    }
-    /**
-     * {@inheritDoc ISharedMap.set}
-     */
-    set(key, value) {
-        // Undefined/null keys can't be serialized to JSON in the manner we currently snapshot.
-        if (key === undefined || key === null) {
-            throw new Error("Undefined and null keys are not supported");
-        }
-        // Create a local value and serialize it.
-        const localValue = this.localValueMaker.fromInMemory(value);
-        const serializableValue = makeSerializable(localValue, this.serializer, this.handle);
-        // Set the value locally.
-        this.setCore(key, localValue, true, undefined);
-        // If we are not attached, don't submit the op.
-        if (!this.isAttached()) {
-            return;
-        }
-        const op = {
-            key,
-            type: "set",
-            value: serializableValue,
-        };
-        this.submitMapKeyMessage(op);
-    }
-    /**
-     * {@inheritDoc IValueTypeCreator.createValueType}
-     */
-    createValueType(key, type, params) {
-        // Create a local value and serialize it.
-        const localValue = this.localValueMaker.makeValueType(type, this.makeMapValueOpEmitter(key), params);
-        // TODO ideally we could use makeSerialized in this case as well. But the interval
-        // collection has assumptions of attach being called prior. Given the IFluidSerializer it
-        // may be possible to remove custom value type serialization entirely.
-        const transformedValue = makeHandlesSerializable(params, this.serializer, this.handle);
-        // Set the value locally.
-        this.setCore(key, localValue, true, undefined);
-        // If we are not attached, don't submit the op.
-        if (!this.isAttached()) {
-            return this;
-        }
-        // This is a special form of serialized valuetype only used for set, containing info for initialization.
-        // After initialization, the serialized form will need to come from the .store of the value type's factory.
-        const serializableValue = { type, value: transformedValue };
-        const op = {
-            key,
-            type: "set",
-            value: serializableValue,
-        };
-        this.submitMapKeyMessage(op);
-        return this;
-    }
-    /**
-     * Delete a key from the map.
-     * @param key - Key to delete
-     * @returns True if the key existed and was deleted, false if it did not exist
-     */
-    delete(key) {
-        // Delete the key locally first.
-        const successfullyRemoved = this.deleteCore(key, true, undefined);
-        // If we are not attached, don't submit the op.
-        if (!this.isAttached()) {
-            return successfullyRemoved;
-        }
-        const op = {
-            key,
-            type: "delete",
-        };
-        this.submitMapKeyMessage(op);
-        return successfullyRemoved;
-    }
-    /**
-     * Clear all data from the map.
-     */
-    clear() {
-        // Clear the data locally first.
-        this.clearCore(true, undefined);
-        // If we are not attached, don't submit the op.
-        if (!this.isAttached()) {
-            return;
-        }
-        const op = {
-            type: "clear",
-        };
-        this.submitMapClearMessage(op);
-    }
-    /**
-     * Serializes the data stored in the shared map to a JSON string
-     * @param serializer - The serializer to use to serialize handles in its values.
-     * @returns A JSON string containing serialized map data
-     */
-    getSerializedStorage(serializer) {
-        const serializableMapData = {};
-        this.data.forEach((localValue, key) => {
-            serializableMapData[key] = localValue.makeSerialized(serializer, this.handle);
-        });
-        return serializableMapData;
-    }
-    getSerializableStorage(serializer) {
-        const serializableMapData = {};
-        this.data.forEach((localValue, key) => {
-            serializableMapData[key] = makeSerializable(localValue, serializer, this.handle);
-        });
-        return serializableMapData;
-    }
-    serialize(serializer) {
-        return JSON.stringify(this.getSerializableStorage(serializer));
-    }
-    /**
-     * Populate the kernel with the given map data.
-     * @param data - A JSON string containing serialized map data
-     */
-    populateFromSerializable(json) {
-        for (const [key, serializable] of Object.entries(json)) {
-            const localValue = {
-                key,
-                value: this.makeLocal(key, serializable),
-            };
-            this.data.set(localValue.key, localValue.value);
-        }
-    }
-    populate(json) {
-        this.populateFromSerializable(JSON.parse(json));
-    }
-    /**
-     * Submit the given op if a handler is registered.
-     * @param op - The operation to attempt to submit
-     * @param localOpMetadata - The local metadata associated with the op. This is kept locally by the runtime
-     * and not sent to the server. This will be sent back when this message is received back from the server. This is
-     * also sent if we are asked to resubmit the message.
-     * @returns True if the operation was submitted, false otherwise.
-     */
-    trySubmitMessage(op, localOpMetadata) {
-        const type = op.type;
-        if (this.messageHandlers.has(type)) {
-            const mapLocalMetadata = 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 === null || mapLocalMetadata === void 0 ? void 0 : mapLocalMetadata.lastProcessedSeq)) {
-                throw new Error("SharedInterval does not support reconnect in presence of external changes");
-            }
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.messageHandlers.get(type).submit(op);
-            return true;
-        }
-        return false;
-    }
-    tryGetStashedOpLocalMetadata(op) {
-        const type = op.type;
-        if (this.messageHandlers.has(type)) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            return this.messageHandlers.get(type).getStashedOpLocalMetadata(op);
-        }
-        throw new Error("no apply stashed op handler");
-    }
-    /**
-     * Process the given op if a handler is registered.
-     * @param message - The message to process
-     * @param local - Whether the message originated from the local client
-     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
-     * For messages from a remote client, this will be undefined.
-     * @returns True if the operation was processed, false otherwise.
-     */
-    tryProcessMessage(op, local, message, localOpMetadata) {
-        // track the seq of every incoming message, so we can detect if any
-        // changes happened during a resubmit
-        this.lastProcessedSeq = message.sequenceNumber;
-        if (this.messageHandlers.has(op.type)) {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            this.messageHandlers
-                .get(op.type)
-                .process(op, local, message, localOpMetadata);
-            return true;
-        }
-        return false;
-    }
-    /**
-     * Set implementation used for both locally sourced sets as well as incoming remote sets.
-     * @param key - The key being set
-     * @param value - The value being set
-     * @param local - Whether the message originated from the local client
-     * @param op - The message if from a remote set, or null if from a local set
-     */
-    setCore(key, value, local, op) {
-        const previousValue = this.get(key);
-        this.data.set(key, value);
-        const event = { key, previousValue };
-        this.eventEmitter.emit("create", event, local, op, this.eventEmitter);
-    }
-    /**
-     * Clear implementation used for both locally sourced clears as well as incoming remote clears.
-     * @param local - Whether the message originated from the local client
-     * @param op - The message if from a remote clear, or null if from a local clear
-     */
-    clearCore(local, op) {
-        this.data.clear();
-        this.eventEmitter.emit("clear", local, op, this.eventEmitter);
-    }
-    /**
-     * Delete implementation used for both locally sourced deletes as well as incoming remote deletes.
-     * @param key - The key being deleted
-     * @param local - Whether the message originated from the local client
-     * @param op - The message if from a remote delete, or null if from a local delete
-     * @returns True if the key existed and was deleted, false if it did not exist
-     */
-    deleteCore(key, local, op) {
-        const previousValue = this.get(key);
-        const successfullyRemoved = this.data.delete(key);
-        if (successfullyRemoved) {
-            const event = { key, previousValue };
-            this.eventEmitter.emit("valueChanged", event, local, op, this.eventEmitter);
-        }
-        return successfullyRemoved;
-    }
-    /**
-     * Clear all keys in memory in response to a remote clear, but retain keys we have modified but not yet been ack'd.
-     */
-    clearExceptPendingKeys() {
-        // Assuming the pendingKeys is small and the map is large
-        // we will get the value for the pendingKeys and clear the map
-        const temp = new Map();
-        this.pendingKeys.forEach((value, key) => {
-            // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            temp.set(key, this.data.get(key));
-        });
-        this.data.clear();
-        temp.forEach((value, key) => {
-            this.data.set(key, value);
-        });
-    }
-    /**
-     * The remote ISerializableValue we're receiving (either as a result of a load or an incoming set op) will
-     * have the information we need to create a real object, but will not be the real object yet.  For example,
-     * we might know it's a map and the map's ID but not have the actual map or its data yet.  makeLocal's
-     * job is to convert that information into a real object for local usage.
-     * @param key - The key that the caller intends to store the local value into (used for ops later).  But
-     * doesn't actually store the local value into that key.  So better not lie!
-     * @param serializable - The remote information that we can convert into a real object
-     * @returns The local value that was produced
-     */
-    makeLocal(key, serializable) {
-        if (serializable.type === ValueType[ValueType.Plain] || serializable.type === ValueType[ValueType.Shared]) {
-            return this.localValueMaker.fromSerializable(serializable);
-        }
-        else {
-            return this.localValueMaker.fromSerializableValueType(serializable, this.makeMapValueOpEmitter(key));
-        }
-    }
-    /**
-     * If our local operations that have not yet been ack'd will eventually overwrite an incoming operation, we should
-     * not process the incoming operation.
-     * @param op - Operation to check
-     * @param local - Whether the message originated from the local client
-     * @param message - The message
-     * @param localOpMetadata - For local client messages, this is the metadata that was submitted with the message.
-     * For messages from a remote client, this will be undefined.
-     * @returns True if the operation should be processed, false otherwise
-     */
-    needProcessKeyOperation(op, local, localOpMetadata) {
-        if (this.pendingClearMessageId !== -1) {
-            if (local) {
-                assert((localOpMetadata === null || localOpMetadata === void 0 ? void 0 : localOpMetadata.pendingClearMessageId) !== undefined
-                    && localOpMetadata.pendingClearMessageId < this.pendingClearMessageId, 0x1f1 /* "Received out of order op when there is an unacked clear message" */);
-            }
-            // If we have an unacked clear, we can ignore all ops.
-            return false;
-        }
-        if (this.pendingKeys.has(op.key)) {
-            // Found an unacked op. Clear it from the map if the pendingMessageId in the map matches this message's
-            // and don't process the op.
-            if (local) {
-                assert(localOpMetadata !== undefined, 0x1f2 /* `pendingMessageId is missing from the local client's ${op.type} operation` */);
-                const pendingMessageId = localOpMetadata.pendingMessageId;
-                const pendingKeyMessageId = this.pendingKeys.get(op.key);
-                if (pendingKeyMessageId === pendingMessageId) {
-                    this.pendingKeys.delete(op.key);
-                }
-            }
-            return false;
-        }
-        // If we don't have a NACK op on the key, we need to process the remote ops.
-        return !local;
-    }
-    /**
-     * Get the message handlers for the map.
-     * @returns A map of string op names to IMapMessageHandlers for those ops
-     */
-    getMessageHandlers() {
-        const messageHandlers = new Map();
-        messageHandlers.set("clear", {
-            process: (op, local, message, localOpMetadata) => {
-                if (local) {
-                    assert(localOpMetadata !== undefined, 0x1f3 /* "pendingMessageId is missing from the local client's clear operation" */);
-                    const pendingMessageId = localOpMetadata === null || localOpMetadata === void 0 ? void 0 : localOpMetadata.pendingMessageId;
-                    if (this.pendingClearMessageId === pendingMessageId) {
-                        this.pendingClearMessageId = -1;
-                    }
-                    return;
-                }
-                if (this.pendingKeys.size !== 0) {
-                    this.clearExceptPendingKeys();
-                    return;
-                }
-                this.clearCore(local, message);
-            },
-            submit: (op) => {
-                // We don't reuse the metadata but send a new one on each submit.
-                this.submitMapClearMessage(op);
-            },
-            getStashedOpLocalMetadata: (op) => {
-                // We don't reuse the metadata but send a new one on each submit.
-                return this.getMapClearMessageLocalMetadata(op);
-            },
-        });
-        messageHandlers.set("delete", {
-            process: (op, local, message, localOpMetadata) => {
-                if (!this.needProcessKeyOperation(op, local, localOpMetadata)) {
-                    return;
-                }
-                this.deleteCore(op.key, local, message);
-            },
-            submit: (op) => {
-                // We don't reuse the metadata but send a new one on each submit.
-                this.submitMapKeyMessage(op);
-            },
-            getStashedOpLocalMetadata: (op) => {
-                // We don't reuse the metadata but send a new one on each submit.
-                return this.getMapKeyMessageLocalMetadata(op);
-            },
-        });
-        messageHandlers.set("set", {
-            process: (op, local, message, localOpMetadata) => {
-                if (!this.needProcessKeyOperation(op, local, localOpMetadata)) {
-                    return;
-                }
-                // needProcessKeyOperation should have returned false if local is true
-                const context = this.makeLocal(op.key, op.value);
-                this.setCore(op.key, context, local, message);
-            },
-            submit: (op) => {
-                // We don't reuse the metadata but send a new one on each submit.
-                this.submitMapKeyMessage(op);
-            },
-            getStashedOpLocalMetadata: (op) => {
-                // We don't reuse the metadata but send a new one on each submit.
-                return this.getMapKeyMessageLocalMetadata(op);
-            },
-        });
-        // Ops with type "act" describe actions taken by custom value type handlers of whatever item is
-        // being addressed.  These custom handlers can be retrieved from the ValueTypeLocalValue which has
-        // stashed its valueType (and therefore its handlers).  We also emit a valueChanged for anyone
-        // watching for manipulations of that item.
-        messageHandlers.set("act", {
-            process: (op, local, message, localOpMetadata) => {
-                // Local value might not exist if we deleted it
-                const localValue = this.data.get(op.key);
-                if (!localValue) {
-                    return;
-                }
-                const handler = localValue.getOpHandler(op.value.opName);
-                const previousValue = localValue.value;
-                const translatedValue = parseHandles(op.value.value, this.serializer);
-                handler.process(previousValue, translatedValue, local, message);
-                const event = { key: op.key, previousValue };
-                this.eventEmitter.emit("valueChanged", event, local, message, this.eventEmitter);
-            },
-            submit: (op) => {
-                this.submitMessage(op, { lastProcessedSeq: this.lastProcessedSeq });
-            },
-            getStashedOpLocalMetadata: (op) => {
-                assert(false, 0x016 /* "apply stashed op not implemented for custom value type ops" */);
-            },
-        });
-        return messageHandlers;
-    }
-    getMapClearMessageLocalMetadata(op) {
-        const pendingMessageId = ++this.pendingMessageId;
-        this.pendingClearMessageId = pendingMessageId;
-        return pendingMessageId;
-    }
-    /**
-     * Submit a clear message to remote clients.
-     * @param op - The clear message
-     */
-    submitMapClearMessage(op) {
-        const pendingClearMessageId = this.getMapClearMessageLocalMetadata(op);
-        this.submitMessage(op, { pendingClearMessageId, lastProcessedSeq: this.lastProcessedSeq });
-    }
-    getMapKeyMessageLocalMetadata(op) {
-        const pendingMessageId = ++this.pendingMessageId;
-        this.pendingKeys.set(op.key, pendingMessageId);
-        return pendingMessageId;
-    }
-    /**
-     * Submit a map key message to remote clients.
-     * @param op - The map key message
-     */
-    submitMapKeyMessage(op) {
-        const pendingMessageId = this.getMapKeyMessageLocalMetadata(op);
-        this.submitMessage(op, { pendingMessageId, lastProcessedSeq: this.lastProcessedSeq });
-    }
-    /**
-     * Create an emitter for a value type to emit ops from the given key.
-     * @alpha
-     * @param key - The key of the map that the value type will be stored on
-     * @returns A value op emitter for the given key
-     */
-    makeMapValueOpEmitter(key) {
-        const emit = (opName, previousValue, params) => {
-            const translatedParams = makeHandlesSerializable(params, this.serializer, this.handle);
-            const op = {
-                key,
-                type: "act",
-                value: {
-                    opName,
-                    value: translatedParams,
-                },
-            };
-            // Send the localOpMetadata as undefined because we don't care about the ack.
-            this.submitMessage(op, { lastProcessedSeq: this.lastProcessedSeq });
-            const event = { key, previousValue };
-            this.eventEmitter.emit("valueChanged", event, true, null, this.eventEmitter);
-        };
-        return { emit };
-    }
-}
-//# sourceMappingURL=mapKernel.js.map