@fluidframework/driver-utils 2.0.0-internal.3.0.1 → 2.0.0-internal.3.1.0

package/src/mapWithExpiration.ts

@@ -10,108 +10,115 @@ import { assert } from "@fluidframework/common-utils";
  * The policy is based on the last time a key was written to.
  */
 export class MapWithExpiration<TKey = any, TValue = any> extends Map<TKey, TValue> {
-    /** Timestamps (as epoch ms numbers) of when each key was last refreshed */
-    private readonly lastRefreshedTimes = new Map<TKey, number>();
-
-    constructor(
-        private readonly expiryMs: number,
-    ) {
-        super();
-    }
-
-    private refresh(key: TKey): void {
-        this.lastRefreshedTimes.set(key, (new Date()).valueOf());
-    }
-
-    /**
-     * Returns true if the key is present and expired, false if it's not expired, and undefined if it's not found
-     * If cleanUp is passed as true, then delete any expired entry before returning.
-     */
-    private checkExpiry(key: TKey, cleanUp: boolean = false): boolean | undefined {
-        const refreshTime = this.lastRefreshedTimes.get(key);
-        assert((refreshTime !== undefined) === super.has(key), 0x50c /* freshness map out of sync */);
-
-        if (refreshTime === undefined) {
-            return undefined;
-        }
-        const expired = (new Date()).valueOf() - refreshTime >= this.expiryMs;
-        if (expired && cleanUp) {
-            this.delete(key);
-        }
-        return expired;
-    }
-
-    private clearExpiredEntries() {
-        // forEach clears out any expired entries
-        this.forEach(() => {});
-    }
-
-    get size(): number {
-        this.clearExpiredEntries();
-        return super.size;
-    }
-
-    has(key: TKey): boolean {
-        this.checkExpiry(key, true /* cleanUp */);
-        return super.has(key);
-    }
-
-    get(key: TKey): TValue | undefined {
-        this.checkExpiry(key, true /* cleanUp */);
-        return super.get(key);
-    }
-
-    set(key: TKey, value: TValue): this {
-        // Sliding window expiration policy (on write)
-        this.refresh(key);
-        return super.set(key, value);
-    }
-
-    delete(key: TKey): boolean {
-        this.lastRefreshedTimes.delete(key);
-        return super.delete(key);
-    }
-
-    clear(): void {
-        this.lastRefreshedTimes.clear();
-        super.clear();
-    }
-
-    forEach(callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void, thisArg?: any): void {
-        const expiredKeys: TKey[] = [];
-        super.forEach((v, k, m) => {
-            if (this.checkExpiry(k) === true) {
-                expiredKeys.push(k);
-            } else {
-                callbackfn.bind(thisArg)(v, k, m);
-            }
-        },
-        // Note we don't pass thisArg here, since we bind it directly to callbackFn and don't need it otherwise
-        );
-
-        // Clean up keys we know are expired now that we're done iterating
-        expiredKeys.forEach((key: TKey) => { this.delete(key); });
-    }
-
-    entries(): IterableIterator<[TKey, TValue]> {
-        this.clearExpiredEntries();
-        return super.entries();
-    }
-    keys(): IterableIterator<TKey> {
-        this.clearExpiredEntries();
-        return super.keys();
-    }
-    values(): IterableIterator<TValue> {
-        this.clearExpiredEntries();
-        return super.values();
-    }
-    [Symbol.iterator](): IterableIterator<[TKey, TValue]> {
-        this.clearExpiredEntries();
-        return super[Symbol.iterator]();
-    }
-
-    valueOf() {
-        this.clearExpiredEntries();
-        return super.valueOf();
-    }
+	/** Timestamps (as epoch ms numbers) of when each key was last refreshed */
+	private readonly lastRefreshedTimes = new Map<TKey, number>();
+
+	constructor(private readonly expiryMs: number) {
+		super();
+	}
+
+	private refresh(key: TKey): void {
+		this.lastRefreshedTimes.set(key, new Date().valueOf());
+	}
+
+	/**
+	 * Returns true if the key is present and expired, false if it's not expired, and undefined if it's not found
+	 * If cleanUp is passed as true, then delete any expired entry before returning.
+	 */
+	private checkExpiry(key: TKey, cleanUp: boolean = false): boolean | undefined {
+		const refreshTime = this.lastRefreshedTimes.get(key);
+		assert(
+			(refreshTime !== undefined) === super.has(key),
+			0x50c /* freshness map out of sync */,
+		);
+
+		if (refreshTime === undefined) {
+			return undefined;
+		}
+		const expired = new Date().valueOf() - refreshTime >= this.expiryMs;
+		if (expired && cleanUp) {
+			this.delete(key);
+		}
+		return expired;
+	}
+
+	private clearExpiredEntries() {
+		// forEach clears out any expired entries
+		this.forEach(() => {});
+	}
+
+	get size(): number {
+		this.clearExpiredEntries();
+		return super.size;
+	}
+
+	has(key: TKey): boolean {
+		this.checkExpiry(key, true /* cleanUp */);
+		return super.has(key);
+	}
+
+	get(key: TKey): TValue | undefined {
+		this.checkExpiry(key, true /* cleanUp */);
+		return super.get(key);
+	}
+
+	set(key: TKey, value: TValue): this {
+		// Sliding window expiration policy (on write)
+		this.refresh(key);
+		return super.set(key, value);
+	}
+
+	delete(key: TKey): boolean {
+		this.lastRefreshedTimes.delete(key);
+		return super.delete(key);
+	}
+
+	clear(): void {
+		this.lastRefreshedTimes.clear();
+		super.clear();
+	}
+
+	forEach(
+		callbackfn: (value: TValue, key: TKey, map: Map<TKey, TValue>) => void,
+		thisArg?: any,
+	): void {
+		const expiredKeys: TKey[] = [];
+		super.forEach(
+			(v, k, m) => {
+				if (this.checkExpiry(k) === true) {
+					expiredKeys.push(k);
+				} else {
+					callbackfn.bind(thisArg)(v, k, m);
+				}
+			},
+			// Note we don't pass thisArg here, since we bind it directly to callbackFn and don't need it otherwise
+		);
+
+		// Clean up keys we know are expired now that we're done iterating
+		expiredKeys.forEach((key: TKey) => {
+			this.delete(key);
+		});
+	}
+
+	entries(): IterableIterator<[TKey, TValue]> {
+		this.clearExpiredEntries();
+		return super.entries();
+	}
+	keys(): IterableIterator<TKey> {
+		this.clearExpiredEntries();
+		return super.keys();
+	}
+	values(): IterableIterator<TValue> {
+		this.clearExpiredEntries();
+		return super.values();
+	}
+	[Symbol.iterator](): IterableIterator<[TKey, TValue]> {
+		this.clearExpiredEntries();
+		return super[Symbol.iterator]();
+	}
+
+	valueOf() {
+		this.clearExpiredEntries();
+		return super.valueOf();
+	}
 }

package/src/messageRecognition.ts

@@ -2,25 +2,29 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { IDocumentMessage, ISequencedDocumentMessage, MessageType } from "@fluidframework/protocol-definitions";
+import {
+	IDocumentMessage,
+	ISequencedDocumentMessage,
+	MessageType,
+} from "@fluidframework/protocol-definitions";
 
 /**
  * Tells if message was sent by container runtime
  * @privateRemarks ADO #1385: To be moved to container-definitions
  * @returns whether the message is a runtime message
  */
-export function isRuntimeMessage(message: { type: string; }): boolean {
-    return message.type === MessageType.Operation;
+export function isRuntimeMessage(message: { type: string }): boolean {
+	return message.type === MessageType.Operation;
 }
 
 enum RuntimeMessage {
-    FluidDataStoreOp = "component",
-    Attach = "attach",
-    ChunkedOp = "chunkedOp",
-    BlobAttach = "blobAttach",
-    Rejoin = "rejoin",
-    Alias = "alias",
-    Operation = "op",
+	FluidDataStoreOp = "component",
+	Attach = "attach",
+	ChunkedOp = "chunkedOp",
+	BlobAttach = "blobAttach",
+	Rejoin = "rejoin",
+	Alias = "alias",
+	Operation = "op",
 }
 
 /**
@@ -43,21 +47,23 @@ enum RuntimeMessage {
  * @deprecated This API should not be used.
  */
 export function isUnpackedRuntimeMessage(message: ISequencedDocumentMessage): boolean {
-    if ((Object.values(RuntimeMessage) as string[]).includes(message.type)) {
-        return true;
-    }
-    return false;
+	if ((Object.values(RuntimeMessage) as string[]).includes(message.type)) {
+		return true;
+	}
+	return false;
 }
 
 // ADO #1385: staging code changes across layers.
 // Eventually to be replaced by MessageType.accept
 export enum MessageType2 {
-    Accept = "accept",
+	Accept = "accept",
 }
 
 // ADO #1385: To be moved to packages/protocol-base/src/protocol.ts
-export function canBeCoalescedByService(message: ISequencedDocumentMessage | IDocumentMessage): boolean {
-    // This assumes that in the future relay service may implement coalescing of accept messages,
-    // same way it was doing coalescing of immediate noops in the past.
-    return message.type === MessageType.NoOp || message.type === MessageType2.Accept;
+export function canBeCoalescedByService(
+	message: ISequencedDocumentMessage | IDocumentMessage,
+): boolean {
+	// This assumes that in the future relay service may implement coalescing of accept messages,
+	// same way it was doing coalescing of immediate noops in the past.
+	return message.type === MessageType.NoOp || message.type === MessageType2.Accept;
 }

package/src/multiDocumentServiceFactory.ts

@@ -5,76 +5,87 @@
 
 import { parse } from "url";
 import {
-    IDocumentServiceFactory,
-    IResolvedUrl,
-    IDocumentService,
+	IDocumentServiceFactory,
+	IResolvedUrl,
+	IDocumentService,
 } from "@fluidframework/driver-definitions";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
 import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
 import { ensureFluidResolvedUrl } from "./fluidResolvedUrl";
 
 export class MultiDocumentServiceFactory implements IDocumentServiceFactory {
-    public static create(documentServiceFactory: IDocumentServiceFactory | IDocumentServiceFactory[]) {
-        if (Array.isArray(documentServiceFactory)) {
-            const factories: IDocumentServiceFactory[] = [];
-            documentServiceFactory.forEach((factory) => {
-                const maybeMulti = factory as MultiDocumentServiceFactory;
-                if (maybeMulti.protocolToDocumentFactoryMap !== undefined) {
-                    factories.push(...maybeMulti.protocolToDocumentFactoryMap.values());
-                } else {
-                    factories.push(factory);
-                }
-            });
-            if (factories.length === 1) {
-                return factories[0];
-            }
-            return new MultiDocumentServiceFactory(factories);
-        }
-        return documentServiceFactory;
-    }
+	public static create(
+		documentServiceFactory: IDocumentServiceFactory | IDocumentServiceFactory[],
+	) {
+		if (Array.isArray(documentServiceFactory)) {
+			const factories: IDocumentServiceFactory[] = [];
+			documentServiceFactory.forEach((factory) => {
+				const maybeMulti = factory as MultiDocumentServiceFactory;
+				if (maybeMulti.protocolToDocumentFactoryMap !== undefined) {
+					factories.push(...maybeMulti.protocolToDocumentFactoryMap.values());
+				} else {
+					factories.push(factory);
+				}
+			});
+			if (factories.length === 1) {
+				return factories[0];
+			}
+			return new MultiDocumentServiceFactory(factories);
+		}
+		return documentServiceFactory;
+	}
 
-    private readonly protocolToDocumentFactoryMap: Map<string, IDocumentServiceFactory>;
+	private readonly protocolToDocumentFactoryMap: Map<string, IDocumentServiceFactory>;
 
-    constructor(documentServiceFactories: IDocumentServiceFactory[]) {
-        this.protocolToDocumentFactoryMap = new Map();
-        documentServiceFactories.forEach((factory: IDocumentServiceFactory) => {
-            this.protocolToDocumentFactoryMap.set(factory.protocolName, factory);
-        });
-    }
-    public readonly protocolName = "none:";
-    async createDocumentService(
-        resolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(resolvedUrl);
-        const urlObj = parse(resolvedUrl.url);
-        if (urlObj.protocol === undefined || urlObj.protocol === null) {
-            throw new Error("No protocol provided");
-        }
-        const factory: IDocumentServiceFactory | undefined = this.protocolToDocumentFactoryMap.get(urlObj.protocol);
-        if (factory === undefined) {
-            throw new Error("Unknown Fluid protocol");
-        }
+	constructor(documentServiceFactories: IDocumentServiceFactory[]) {
+		this.protocolToDocumentFactoryMap = new Map();
+		documentServiceFactories.forEach((factory: IDocumentServiceFactory) => {
+			this.protocolToDocumentFactoryMap.set(factory.protocolName, factory);
+		});
+	}
+	public readonly protocolName = "none:";
+	async createDocumentService(
+		resolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		ensureFluidResolvedUrl(resolvedUrl);
+		const urlObj = parse(resolvedUrl.url);
+		if (urlObj.protocol === undefined || urlObj.protocol === null) {
+			throw new Error("No protocol provided");
+		}
+		const factory: IDocumentServiceFactory | undefined = this.protocolToDocumentFactoryMap.get(
+			urlObj.protocol,
+		);
+		if (factory === undefined) {
+			throw new Error("Unknown Fluid protocol");
+		}
 
-        return factory.createDocumentService(resolvedUrl, logger, clientIsSummarizer);
-    }
+		return factory.createDocumentService(resolvedUrl, logger, clientIsSummarizer);
+	}
 
-    public async createContainer(
-        createNewSummary: ISummaryTree,
-        createNewResolvedUrl: IResolvedUrl,
-        logger?: ITelemetryBaseLogger,
-        clientIsSummarizer?: boolean,
-    ): Promise<IDocumentService> {
-        ensureFluidResolvedUrl(createNewResolvedUrl);
-        const urlObj = parse(createNewResolvedUrl.url);
-        if (urlObj.protocol === undefined || urlObj.protocol === null) {
-            throw new Error("No protocol provided");
-        }
-        const factory: IDocumentServiceFactory | undefined = this.protocolToDocumentFactoryMap.get(urlObj.protocol);
-        if (factory === undefined) {
-            throw new Error("Unknown Fluid protocol");
-        }
-        return factory.createContainer(createNewSummary, createNewResolvedUrl, logger, clientIsSummarizer);
-    }
+	public async createContainer(
+		createNewSummary: ISummaryTree,
+		createNewResolvedUrl: IResolvedUrl,
+		logger?: ITelemetryBaseLogger,
+		clientIsSummarizer?: boolean,
+	): Promise<IDocumentService> {
+		ensureFluidResolvedUrl(createNewResolvedUrl);
+		const urlObj = parse(createNewResolvedUrl.url);
+		if (urlObj.protocol === undefined || urlObj.protocol === null) {
+			throw new Error("No protocol provided");
+		}
+		const factory: IDocumentServiceFactory | undefined = this.protocolToDocumentFactoryMap.get(
+			urlObj.protocol,
+		);
+		if (factory === undefined) {
+			throw new Error("Unknown Fluid protocol");
+		}
+		return factory.createContainer(
+			createNewSummary,
+			createNewResolvedUrl,
+			logger,
+			clientIsSummarizer,
+		);
+	}
 }

package/src/multiUrlResolver.ts

@@ -12,40 +12,37 @@ import { IResolvedUrl, IUrlResolver } from "@fluidframework/driver-definitions";
  * @param request - Request to be resolved.
  */
 export async function configurableUrlResolver(
-    resolversList: IUrlResolver[],
-    request: IRequest,
+	resolversList: IUrlResolver[],
+	request: IRequest,
 ): Promise<IResolvedUrl | undefined> {
-    let resolved: IResolvedUrl | undefined;
-    for (const resolver of resolversList) {
-        resolved = await resolver.resolve({ ...request });
-        if (resolved !== undefined) {
-            return resolved;
-        }
-    }
-    return undefined;
+	let resolved: IResolvedUrl | undefined;
+	for (const resolver of resolversList) {
+		resolved = await resolver.resolve({ ...request });
+		if (resolved !== undefined) {
+			return resolved;
+		}
+	}
+	return undefined;
 }
 
 export class MultiUrlResolver implements IUrlResolver {
-    public static create(urlResolver: IUrlResolver | IUrlResolver[]) {
-        if (Array.isArray(urlResolver)) {
-            if (urlResolver.length === 1) {
-                return urlResolver[0];
-            }
-            return new MultiUrlResolver(urlResolver);
-        }
-        return urlResolver;
-    }
+	public static create(urlResolver: IUrlResolver | IUrlResolver[]) {
+		if (Array.isArray(urlResolver)) {
+			if (urlResolver.length === 1) {
+				return urlResolver[0];
+			}
+			return new MultiUrlResolver(urlResolver);
+		}
+		return urlResolver;
+	}
 
-    private constructor(private readonly urlResolvers: IUrlResolver[]) { }
+	private constructor(private readonly urlResolvers: IUrlResolver[]) {}
 
-    async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
-        return configurableUrlResolver(this.urlResolvers, request);
-    }
+	async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
+		return configurableUrlResolver(this.urlResolvers, request);
+	}
 
-    public async getAbsoluteUrl(
-        resolvedUrl: IResolvedUrl,
-        relativeUrl: string,
-    ): Promise<string> {
-        throw new Error("Not implmented");
-    }
+	public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
+		throw new Error("Not implmented");
+	}
 }