@fluid-experimental/tree 0.58.2002 → 0.59.1000

package/dist/id-compressor/IdCompressor.d.ts

@@ -0,0 +1,389 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import { LocalCompressedId, FinalCompressedId, SessionSpaceCompressedId, StableId, OpSpaceCompressedId, SessionId, CompressedId } from '../Identifiers';
+import type { AttributionInfo, IdCreationRange, SerializedIdCompressorWithNoSession, SerializedIdCompressorWithOngoingSession, VersionedSerializedIdCompressor } from './persisted-types';
+/**
+ * Roughly equates to a minimum of 1M sessions before we start allocating 64 bit IDs.
+ * This value must *NOT* change without careful consideration to compatibility.
+ */
+export declare const defaultClusterCapacity = 512;
+/**
+ * The ID override for the initial tree of a SharedTree. An artifact of an unfortunate typo which included an extraneous '6' on the UUID
+ * which must be forever preserved for backwards compatibility.
+ */
+export declare const legacySharedTreeInitialTreeId = "24e26f0b-3c1a-47f8-a7a1-e8461ddb69ce6";
+/**
+ * @returns true if the supplied ID is a final ID.
+ */
+export declare function isFinalId(id: CompressedId): id is FinalCompressedId;
+/**
+ * @returns true if the supplied ID is a local ID.
+ */
+export declare function isLocalId(id: CompressedId): id is LocalCompressedId;
+/**
+ * A object for retrieving the session-space IDs for a range of IDs.
+ * Optimized to avoid allocating an array of IDs.
+ */
+export interface IdRange {
+    /**
+     * The length of the ID range.
+     */
+    readonly length: number;
+    /**
+     * Returns the ID in range at the provided index.
+     */
+    get(index: number): SessionSpaceCompressedId;
+}
+/**
+ * A serializable descriptor of a range of session-space IDs.
+ * The contained IDs must be retrieved by calling `getIdsFromRange`, which returns an `IdRange`.
+ */
+export interface IdRangeDescriptor<TId extends LocalCompressedId | OpSpaceCompressedId> {
+    readonly first: TId;
+    readonly count: number;
+}
+/**
+ * A distributed UUID generator and compressor.
+ *
+ * Generates arbitrary non-colliding v4 UUIDs, called stable IDs, for multiple "sessions" (which can be distributed across the network),
+ * providing each session with the ability to map these UUIDs to `numbers`.
+ *
+ * A session is a unique identifier that denotes a single compressor. New IDs are created through a single compressor API
+ * which should then sent in ranges to the server for total ordering (and are subsequently relayed to other clients). When a new ID is
+ * created it is said to be created by the compressor's "local" session.
+ *
+ * For each stable ID created, two numeric IDs are provided by the compressor:
+ * 	1. A local ID, which is stable for the lifetime of the session (which could be longer than that of the compressor object, as it may
+ * 		be serialized for offline usage). Available as soon as the stable ID is allocated. Local IDs are session-unique and are thus only
+ * 		publicly usable by the compressor that created the stable ID.
+ * 	2. A final ID, which is stable across serialization and deserialization of an IdCompressor. Available as soon as the range containing
+ * 		the corresponding local ID is totally ordered (via consensus) with respect to other sessions' allocations.
+ * 		Final IDs are known to and publicly usable by any compressor that has received them.
+ *
+ * Compressors will allocate UUIDs in non-random ways to reduce entropy allowing for optimized storage of the data needed
+ * to map the UUIDs to the numbers.
+ *
+ * A client may optionally supply an "override" for any generated ID, associating an arbitrary string with the local/final ID rather than
+ * the UUID that would otherwise be created.
+ *
+ * The following invariants are upheld by IdCompressor:
+ * 1. Local IDs will always decompress to the same UUIDs (or override string) for the lifetime of the session.
+ * 2. Final IDs will always decompress to the same UUIDs (or override string).
+ * 3. After a server-processed range of local IDs (from any session) is received by a compressor, any of those local IDs may be
+ * 		translated by the compressor into the corresponding final ID. For any given local ID, this translation will always yield the
+ * 		same final ID.
+ * 4. A UUID (or override string) will always compress into the same session-space ID for the lifetime of the session.
+ *
+ * Local IDs are sent across the wire in efficiently-represented ranges. These ranges are created by querying the compressor, and *must*
+ * be ordered (i.e. sent to the server) in the order they are created in order to preserve the above invariants.
+ *
+ * Session-local IDs can be used immediately after creation, but will eventually (after being sequenced) have a corresponding final ID. This
+ * could make reasoning about equality of those two forms (the local and final) difficult. For example, if a cache is keyed off of a
+ * local ID but is later queried using the final ID (which is semantically equal, as it decompresses to the same UUID/string) it will
+ * produce a cache miss. In order to make using collections of both remotely created and locally created IDs easy, regardless of whether the
+ * session-local IDs have been finalized, the compressor defines two "spaces" of IDs:
+ *
+ * 1. Session space: in this space, all IDs are normalized to their "most local form". This means that all IDs created by the local session
+ * will be in local form, regardless of if they have been finalized. Remotely created IDs, which could only have been received after
+ * finalizing and will never have a local form for the compressor, will of course be final IDs. This space should be used with consumer APIs
+ * and data structures, as the lifetime of the IDs is guaranteed to be the same as the compressor object. Care must be taken to not use
+ * these IDs across compressor objects, as the local IDs are specific to the compressor that created them.
+ *
+ * 2. Op space: in this space, all IDs are normalized to their "most final form". This means that all IDs except session-local IDs that
+ * have not yet been finalized will be in final ID form. This space is useful for serialization in ops (e.g. references), as other clients
+ * that receive them need not do any work to normalize them to *their* session-space in the common case. Note that IDs in op space may move
+ * out of Op space over time, namely, when a local ID in this space becomes finalized, and thereafter has a "more final form".
+ * Consequentially, it may be useful to restrict parameters of a persisted type to this space (to optimize perf), but it is potentially
+ * incorrect to use this type for a runtime variable. This is an asymmetry that does not affect session space, as local IDs are always as
+ * "local as possible".
+ *
+ * These two spaces naturally define a rule: consumers of compressed IDs should use session-space IDs, but serialized forms such as ops
+ * should use op-space IDs.
+ *
+ */
+export declare class IdCompressor {
+    readonly localSessionId: SessionId;
+    readonly reservedIdCount: number;
+    /**
+     * Max allowed cluster size
+     */
+    static maxClusterSize: number;
+    /**
+     * Trivially reach consensus on default cluster size and reserved IDs.
+     * These initial values must *NOT* change without careful consideration to compatibility.
+     */
+    private newClusterCapacity;
+    /**
+     * The size of each newly created ID cluster.
+     */
+    get clusterCapacity(): number;
+    /**
+     * Must only be set with a value upon which consensus has been reached. Value must be greater than zero and less than
+     * `IdCompressor.maxClusterSize`.
+     */
+    set clusterCapacity(value: number);
+    /**
+     * Session ID -> data about the session's current cluster.
+     * Sessions are mutable, and thus should only be created via `createSession`.
+     */
+    private readonly sessions;
+    /**
+     * The `IdCompressor`'s current local session.
+     */
+    private readonly localSession;
+    /**
+     * Boolean to track whether attribution has been sent with an ID range yet. Prevents unnecessary bloat of ranges.
+     */
+    private sentAttributionInfo;
+    /**
+     * The base final ID of the next cluster to be created.
+     */
+    private nextClusterBaseFinalId;
+    /**
+     * Total number of IDs created locally during the current session.
+     */
+    private localIdCount;
+    /**
+     * The most recent (i.e. smallest, due to being negative) local ID in a range returned by `takeNextCreationRange`.
+     * Undefined if no non-empty ranges have ever been returned by this compressor.
+     */
+    private lastTakenLocalId;
+    /**
+     * Maps local IDs to override strings. This will contain an entry for every override assigned to a local ID generated during
+     * the current session, and retains entries for the lifetime of this compressor.
+     */
+    private readonly localOverrides;
+    /**
+     * Maps local IDs to the cluster they belong to (if any). This can be used to efficiently convert a local ID to a
+     * final ID by finding an entry <= a given local ID (to find the cluster it is associated with) and checking
+     * it against `numFinalizedLocalIds`.
+     */
+    private readonly localIdToCluster;
+    /**
+     * Contains entries for cluster base UUIDs and override strings (both local and final).
+     * As a performance optimization, entries for finalized strings also include the containing cluster object.
+     * This can be viewed as three separate tables: the inverse table for `localOverrides`, the inverse table for the union of all
+     * the overrides of the clusters in `finalIdToCluster`, and the inverse lookup of cluster base UUIDs to their clusters.
+     * This is unified as a performance optimization, as the common case does not have overridden IDs. It is a btree due to the need
+     * to make range queries.
+     */
+    private readonly clustersAndOverridesInversion;
+    /**
+     * Maps the first final ID in a cluster to its owning cluster.
+     * Can be searched in O(log n) to determine clusters for any final ID.
+     */
+    private readonly finalIdToCluster;
+    /**
+     * Helper comparator for searching append-only sorted maps.
+     */
+    private static overrideComparator;
+    /**
+     * @param localSessionId the `IdCompressor`'s current local session ID.
+     * @param reservedIdCount the number of IDs that will be known by this compressor without relying on consensus. The reserved ID count
+     * for a given session must be constant for any compressor that contains IDs from that session (i.e. any DDS that uses the ID
+     * compressor must have the same reservedIdCount forever). Compressors with different reserved ID counts will fail to synchronize their
+     * IDs.
+     * @param attributionInfo information used by other clients to attribute IDs made by this client
+     */
+    constructor(localSessionId: SessionId, reservedIdCount: number, attributionInfo?: AttributionInfo);
+    /**
+     * Creates a session object for the supplied ID.
+     * Must only be called once per ID.
+     * @param sessionId the ID for the session
+     * @returns the session object for the supplied ID
+     */
+    private createSession;
+    private tryGetSession;
+    /**
+     * Return the nth reserved ID.
+     * @param index the index of the ID to return
+     */
+    getReservedId(index: number): SessionSpaceCompressedId & FinalCompressedId;
+    /**
+     * Returns an iterable of all IDs created by this compressor.
+     */
+    getAllIdsFromLocalSession(): IterableIterator<SessionSpaceCompressedId>;
+    /**
+     * Returns the attribution info associated with the compressor that created the ID, if it exists.
+     */
+    attributeId(id: SessionSpaceCompressedId): AttributionInfo | undefined;
+    /**
+     * Provides the session-space IDs corresponding to a range of IDs.
+     * See `IdRange` for more details.
+     */
+    getIdsFromRange(rangeDescriptor: IdRangeDescriptor<SessionSpaceCompressedId>, sessionId: SessionId): IdRange;
+    /**
+     * Returns a range of local IDs created by this session in a format for sending to the server for finalizing.
+     * The range will include all local IDs generated via calls to `generateCompressedId` since the last time this method was called.
+     * @returns the range of session-local IDs, which may be empty. This range must be sent to the server for ordering before
+     * it is finalized. Ranges must be sent to the server in the order that they are taken via calls to this method.
+     */
+    takeNextCreationRange(): IdCreationRange;
+    /**
+     * Finalizes the supplied range of IDs (which may be from either a remote or local session).
+     * @param range the range of session-local IDs to finalize.
+     */
+    finalizeCreationRange(range: IdCreationRange): void;
+    private checkClusterForCollision;
+    private static failWithCollidingOverride;
+    private static isClusterInfo;
+    private static isUnfinalizedOverride;
+    private static createInversionKey;
+    private static isStableInversionKey;
+    /**
+     * Returns an existing ID associated with an override, or undefined if none exists.
+     */
+    private getExistingIdsForNewOverride;
+    /**
+     * Check if `a` might be within `range` of `b`, where both are treated as hex numbers.
+     * @param range an integer
+     */
+    private static uuidsMightCollide;
+    /**
+     * Helper for retrieving an override.
+     */
+    private static tryGetOverride;
+    /**
+     * Generates a new compressed ID or returns an existing one.
+     * This should ONLY be called to generate IDs for local operations.
+     * @param override Specifies a specific string to be associated with the returned compressed ID.
+     * Performance note: assigning override strings incurs a performance overhead.
+     * @returns an existing ID if one already exists for `override`, and a new local ID otherwise. The returned ID is in session space.
+     */
+    generateCompressedId(override?: string): SessionSpaceCompressedId;
+    /**
+     * Generates a range of compressed IDs.
+     * This should ONLY be called to generate IDs for local operations.
+     * @param count the number of IDs to generate, must be > 0.
+     * @returns a persistable descriptor of the ID range.
+     */
+    generateCompressedIdRange(count: number): IdRangeDescriptor<LocalCompressedId>;
+    private generateNextLocalId;
+    /**
+     * Decompresses a previously compressed ID into a UUID or override string.
+     * @param id the compressed ID to be decompressed.
+     * @returns the UUID or override string associated with the compressed ID. Fails if the ID was not generated by this compressor.
+     */
+    decompress(id: SessionSpaceCompressedId | FinalCompressedId): StableId | string;
+    /**
+     * Attempts to decompress a previously compressed ID into a UUID or override string.
+     * @param id the compressed ID to be decompressed.
+     * @returns the UUID or override string associated with the compressed ID, or undefined if the ID was not generated by this compressor.
+     */
+    tryDecompress(id: SessionSpaceCompressedId | FinalCompressedId): StableId | string | undefined;
+    /**
+     * Recompresses a decompressed ID, which could be a UUID or an override string.
+     * @param uncompressed the UUID or override string to recompress.
+     * @returns the `CompressedId` associated with `uncompressed`. Fails if it has not been previously compressed by this compressor.
+     */
+    recompress(uncompressed: string): SessionSpaceCompressedId;
+    /**
+     * Attempts to recompresses a decompressed ID, which could be a UUID or an override string.
+     * @param uncompressed the UUID or override string to recompress,
+     * @returns the `CompressedId` associated with `uncompressed` or undefined if it has not been previously compressed by this compressor.
+     */
+    tryRecompress(uncompressed: string): SessionSpaceCompressedId | undefined;
+    /**
+     * Helper to compress an uncompressed UUID. It can optionally be supplied with the numeric form of `uncompressedUuid` as a
+     * performance optimization.
+     */
+    private recompressInternal;
+    /**
+     * Normalizes a session space ID into op space.
+     * @param id the local ID to normalize.
+     * @returns the ID in op space.
+     */
+    normalizeToOpSpace(id: SessionSpaceCompressedId): OpSpaceCompressedId;
+    /**
+     * Normalizes an ID into session space.
+     * @param id the ID to normalize. If it is a local ID, it is assumed to have been created by the session corresponding
+     * to `sessionId`.
+     * @param originSessionId the session from which `id` originated
+     * @returns the session-space ID corresponding to `id`, which might not have been a final ID if the client that created it had not yet
+     * finalized it. This can occur when a client references an ID during the window of time in which it is waiting to receive the ordered
+     * range that contained it from the server.
+     */
+    normalizeToSessionSpace(id: OpSpaceCompressedId, originSessionId: SessionId): SessionSpaceCompressedId;
+    /**
+     * Normalizes a final ID into session space.
+     * @param id the final ID to normalize.
+     * @returns the session-space ID corresponding to `id`.
+     */
+    normalizeToSessionSpace(id: FinalCompressedId): SessionSpaceCompressedId;
+    /**
+     * Returns the session-space compressed ID corresponding to the numeric UUID, or undefined if it is not known to this compressor.
+     * Typically, it will return the session-space ID sequentially aligned with it (which will be local if `numericUuid` was made by
+     * the local session, or final otherwise). However, in the event that the aligned session-space ID was overridden with a UUID
+     * *and* that override UUID was concurrently used in an older ID (earlier, w.r.t. sequencing), this method can return the first
+     * ID to correspond to that override.
+     *
+     * As an example, consider the following two clients:
+     * ClientA, session UUID: A0000000-0000-0000-0000-000000000000
+     * ClientB, session UUID: B0000000-0000-0000-0000-000000000000
+     *
+     * If concurrently, two clients performed:
+     * ClientA: generateCompressedId(override: 'X0000000-0000-0000-0000-000000000000') // aligned with A0000000-0000-0000-0000-000000000000
+     *
+     * ClientB: generateCompressedId() // aligned with B0000000-0000-0000-0000-000000000000
+     * ClientB: generateCompressedId(override: 'X0000000-0000-0000-0000-000000000000') // aligned with B0000000-0000-0000-0000-000000000001
+     *
+     * After sequencing, calling this method and passing the numeric UUID for B0000000-0000-0000-0000-000000000001 would return the
+     * session-space ID corresponding to A0000000-0000-0000-0000-000000000000 (with override X0000000-0000-0000-0000-000000000000).
+     */
+    private compressNumericUuid;
+    private getLocalIdForStableId;
+    private getClusterForFinalId;
+    /**
+     * @returns if `other` is equal to this `IdCompressor`. The equality check includes local session state.
+     * @testOnly
+     */
+    equals(other: IdCompressor, compareLocalState: boolean): boolean;
+    private static sessionDataEqual;
+    private static idClustersEqual;
+    /**
+     * Returns a persistable form of the current state of this `IdCompressor` which can be rehydrated via `IdCompressor.deserialize()`.
+     * This includes finalized state as well as un-finalized state and is therefore suitable for use in offline scenarios.
+     */
+    serialize(withSession: boolean): SerializedIdCompressorWithOngoingSession | SerializedIdCompressorWithNoSession;
+    /**
+     * Returns a persistable form of the current state of this `IdCompressor` which can be rehydrated via `IdCompressor.deserialize()`.
+     * This includes finalized state as well as un-finalized state and is therefore suitable for use in offline scenarios.
+     */
+    serialize(withSession: true): SerializedIdCompressorWithOngoingSession;
+    /**
+     * Returns a persistable form of the current state of this `IdCompressor` which can be rehydrated via `IdCompressor.deserialize()`.
+     * This only includes finalized state and is therefore suitable for use in summaries.
+     */
+    serialize(withSession: false): SerializedIdCompressorWithNoSession;
+    /**
+     * Deserialize an serialized IdCompressor that is part of an ongoing session, thereby resuming that session.
+     */
+    static deserialize(serialized: SerializedIdCompressorWithOngoingSession): IdCompressor;
+    /**
+     * Deserialize an serialized IdCompressor with a new session. The provided serialized compressor
+     * must have an ongoing session.
+     * @param serialized the serialized compressor state
+     * @param newSessionId the session ID for the new compressor.
+     * @param attributionInfo information used by other clients to attribute IDs made by this client
+     */
+    static deserialize(serialized: SerializedIdCompressorWithNoSession, newSessionId: SessionId, attributionInfo?: AttributionInfo): IdCompressor;
+    /**
+     * Converts the given serialized compressor to the current version.
+     * @param serializedCompressor the serialized compressor to convert. Must not have been serialized with an ongoing session.
+     * @returns a serialized compressor with no ongoing session.
+     */
+    static convertToCurrentVersion(serializedCompressor: VersionedSerializedIdCompressor, hasSession: false): SerializedIdCompressorWithNoSession;
+    /**
+     * Converts the given serialized compressor to the current version.
+     * @param serializedCompressor the serialized compressor to convert. Must have been serialized with an ongoing session.
+     * @returns a serialized compressor with the same ongoing session.
+     */
+    static convertToCurrentVersion(serializedCompressor: VersionedSerializedIdCompressor, hasSession: true): SerializedIdCompressorWithOngoingSession;
+}
+/**
+ * @returns whether or not the given serialized ID compressor has an ongoing session.
+ */
+export declare function hasOngoingSession(serialized: SerializedIdCompressorWithNoSession | SerializedIdCompressorWithOngoingSession): serialized is SerializedIdCompressorWithOngoingSession;
+//# sourceMappingURL=IdCompressor.d.ts.map

package/dist/id-compressor/IdCompressor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"IdCompressor.d.ts","sourceRoot":"","sources":["../../src/id-compressor/IdCompressor.ts"],"names":[],"mappings":"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"}