@fluidframework/odsp-driver 2.0.0-dev.6.4.0.192049 → 2.0.0-dev.7.2.0.203917

package/src/odspDocumentDeltaConnection.ts

@@ -22,12 +22,13 @@ import {
 	ISequencedDocumentMessage,
 	ISignalMessage,
 } from "@fluidframework/protocol-definitions";
-import { Socket, io as SocketIOClientStatic } from "socket.io-client";
+import { Socket } from "socket.io-client";
 import { v4 as uuid } from "uuid";
 import { createGenericNetworkError } from "@fluidframework/driver-utils";
 import { IOdspSocketError, IGetOpsResponse, IFlushOpsResponse } from "./contracts";
 import { EpochTracker } from "./epochTracker";
 import { errorObjectFromSocketError } from "./odspError";
+import { SocketIOClientStatic } from "./socketModule";
 import { pkgVersion } from "./packageVersion";
 
 const protocolVersions = ["^0.4.0", "^0.3.0", "^0.2.0", "^0.1.0"];
@@ -118,7 +119,10 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 		return this._socket;
 	}
 
-	public constructor(public readonly key: string, socket: Socket) {
+	public constructor(
+		public readonly key: string,
+		socket: Socket,
+	) {
 		super();
 
 		this._socket = socket;
@@ -128,28 +132,33 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 		// Server sends this event when it wants to disconnect a particular client in which case the client id would
 		// be present or if it wants to disconnect all the clients. The server always closes the socket in case all
 		// clients needs to be disconnected. So fully remove the socket reference in this case.
-		socket.on("server_disconnect", (socketError: IOdspSocketError, clientId?: string) => {
-			// Treat all errors as recoverable, and rely on joinSession / reconnection flow to
-			// filter out retryable vs. non-retryable cases.
-			const error = errorObjectFromSocketError(socketError, "server_disconnect");
-			error.addTelemetryProperties({ disconnectClientId: clientId });
-			error.canRetry = true;
-
-			// see comment in disconnected() getter
-			// Setting it here to ensure socket reuse does not happen if new request to connect
-			// comes in from "disconnect" listener below, before we close socket.
-			this.isPendingInitialConnection = false;
-
-			if (clientId === undefined) {
-				// We could first raise "disconnect" event, but that may result in socket reuse due to
-				// new connection comming in. So, it's better to have more explicit flow to make it impossible.
-				this.closeSocket(error);
-			} else {
-				this.emit("disconnect", error, clientId);
-			}
-		});
+		socket.on("server_disconnect", this.serverDisconnectEventHandler);
 	}
 
+	private readonly serverDisconnectEventHandler = (
+		socketError: IOdspSocketError,
+		clientId?: string,
+	) => {
+		// Treat all errors as recoverable, and rely on joinSession / reconnection flow to
+		// filter out retryable vs. non-retryable cases.
+		const error = errorObjectFromSocketError(socketError, "server_disconnect");
+		error.addTelemetryProperties({ disconnectClientId: clientId });
+		error.canRetry = true;
+
+		// see comment in disconnected() getter
+		// Setting it here to ensure socket reuse does not happen if new request to connect
+		// comes in from "disconnect" listener below, before we close socket.
+		this.isPendingInitialConnection = false;
+
+		if (clientId === undefined) {
+			// We could first raise "disconnect" event, but that may result in socket reuse due to
+			// new connection comming in. So, it's better to have more explicit flow to make it impossible.
+			this.closeSocket(error);
+		} else {
+			this.emit("disconnect", error, clientId);
+		}
+	};
+
 	private clearTimer() {
 		if (this.delayDeleteTimeout !== undefined) {
 			clearTimeout(this.delayDeleteTimeout);
@@ -162,6 +171,7 @@ class SocketReference extends TypedEventEmitter<ISocketEvents> {
 			return;
 		}
 
+		this._socket.off("server_disconnect", this.serverDisconnectEventHandler);
 		this.clearTimer();
 
 		assert(
@@ -526,23 +536,30 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 				}
 			};
 
-			this.earlySignalHandler = (msg: ISignalMessage, messageDocumentId?: string) => {
+			this.earlySignalHandler = (
+				msg: ISignalMessage | ISignalMessage[],
+				messageDocumentId?: string,
+			) => {
 				if (messageDocumentId === undefined || messageDocumentId === this.documentId) {
-					this.queuedSignals.push(msg);
+					if (Array.isArray(msg)) {
+						this.queuedSignals.push(...msg);
+					} else {
+						this.queuedSignals.push(msg);
+					}
 				}
 			};
 		}
 
 		this.socketReference!.on("disconnect", this.disconnectHandler);
 
-		this.socket.on("get_ops_response", (result: IGetOpsResponse) => {
+		this.addTrackedListener("get_ops_response", (result: IGetOpsResponse) => {
 			const messages = result.messages;
 			const data = this.getOpsMap.get(result.nonce);
 			// Due to socket multiplexing, this client may not have asked for any data
 			// If so, there it most likely does not need these ops (otherwise it already asked for them)
 			// Also we may have deleted entry in this.getOpsMap due to too many requests and too slow response.
 			// But not processing such result may push us into infinite loop of fast requests and dropping all responses
-			if (data !== undefined || result.nonce.indexOf(this.requestOpsNoncePrefix) === 0) {
+			if (data !== undefined || result.nonce.startsWith(this.requestOpsNoncePrefix)) {
 				this.getOpsMap.delete(result.nonce);
 				const common = {
 					eventName: "GetOps",
@@ -570,7 +587,7 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 			}
 		});
 
-		this.socket.on("flush_ops_response", (result: IFlushOpsResponse) => {
+		this.addTrackedListener("flush_ops_response", (result: IFlushOpsResponse) => {
 			if (this.flushOpNonce === result.nonce) {
 				const seq = result.lastPersistedSequenceNumber;
 				let category: "generic" | "error" = "generic";
@@ -624,11 +641,18 @@ export class OdspDocumentDeltaConnection extends DocumentDeltaConnection {
 
 			case "signal":
 				// per document signal handling
-				super.addTrackedListener(event, (msg: ISignalMessage, documentId?: string) => {
-					if (!this.enableMultiplexing || !documentId || documentId === this.documentId) {
-						listener(msg, documentId);
-					}
-				});
+				super.addTrackedListener(
+					event,
+					(msg: ISignalMessage | ISignalMessage[], documentId?: string) => {
+						if (
+							!this.enableMultiplexing ||
+							!documentId ||
+							documentId === this.documentId
+						) {
+							listener(msg, documentId);
+						}
+					},
+				);
 				break;
 
 			case "nack":

package/src/odspDocumentServiceFactory.ts

@@ -17,6 +17,7 @@ import { LocalOdspDocumentServiceFactory } from "./localOdspDriver/localOdspDocu
 /**
  * Factory for creating the sharepoint document service. Use this if you want to
  * use the sharepoint implementation.
+ * @public
  */
 export class OdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
 	constructor(
@@ -29,6 +30,9 @@ export class OdspDocumentServiceFactory extends OdspDocumentServiceFactoryCore {
 	}
 }
 
+/**
+ * @public
+ */
 export function createLocalOdspDocumentServiceFactory(
 	localSnapshot: Uint8Array | string,
 ): IDocumentServiceFactory {

package/src/odspDocumentServiceFactoryCore.ts

@@ -50,6 +50,7 @@ import {
  *
  * This constructor should be used by environments that support dynamic imports and that wish
  * to leverage code splitting as a means to keep bundles as small as possible.
+ * @public
  */
 export class OdspDocumentServiceFactoryCore
 	implements IDocumentServiceFactory, IRelaySessionAwareDriverFactory

package/src/odspDocumentServiceFactoryWithCodeSplit.ts

@@ -13,8 +13,9 @@ import {
 import { OdspDocumentServiceFactoryCore } from "./odspDocumentServiceFactoryCore";
 
 /**
- * @deprecated - This is deprecated in favour of OdspDocumentServiceFactory as the socket io is now loaded inside the
+ * @deprecated This is deprecated in favour of OdspDocumentServiceFactory as the socket io is now loaded inside the
  * other dynamically imported module.
+ * @public
  */
 export class OdspDocumentServiceFactoryWithCodeSplit
 	extends OdspDocumentServiceFactoryCore

package/src/odspDocumentStorageServiceBase.ts

@@ -131,18 +131,6 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 		this.policies = {
 			// By default, ODSP tells the container not to prefetch/cache.
 			caching: LoaderCachingPolicy.NoCaching,
-
-			// ODSP storage works better if it has less number of blobs / edges
-			// Runtime creating many small blobs results in sub-optimal perf.
-			// 2K seems like the sweat spot:
-			// The smaller the number, less blobs we aggregate. Most storages are very likely to have notion
-			// of minimal "cluster" size, so having small blobs is wasteful
-			// At the same time increasing the limit ensure that more blobs with user content are aggregated,
-			// reducing possibility for de-duping of same blobs (i.e. .attributes rolled into aggregate blob
-			// are not reused across data stores, or even within data store, resulting in duplication of content)
-			// Note that duplication of content should not have significant impact for bytes over wire as
-			// compression of http payload mostly takes care of it, but it does impact storage size and in-memory sizes.
-			minBlobSize: 2048,
 			maximumCacheDurationMs: maximumCacheDurationMsInEffect,
 		};
 	}
@@ -169,9 +157,7 @@ export abstract class OdspDocumentStorageServiceBase implements IDocumentStorage
 		return this._snapshotSequenceNumber;
 	}
 
-	public get repositoryUrl(): string {
-		return "";
-	}
+	public readonly repositoryUrl = "";
 
 	public abstract createBlob(file: ArrayBufferLike): Promise<api.ICreateBlobResponse>;
 

package/src/odspDriverUrlResolver.ts

@@ -80,6 +80,7 @@ function removeBeginningSlash(str: string): string {
 /**
  * Resolver to resolve urls like the ones created by createOdspUrl which is driver inner
  * url format. Ex: `${siteUrl}?driveId=${driveId}&itemId=${itemId}&path=${path}`
+ * @public
  */
 export class OdspDriverUrlResolver implements IUrlResolver {
 	constructor() {}
@@ -94,6 +95,7 @@ export class OdspDriverUrlResolver implements IUrlResolver {
 			const filePath = searchParams.get("path");
 			const packageName = searchParams.get("containerPackageName");
 			const createLinkType = searchParams.get("createLinkType");
+			// eslint-disable-next-line @typescript-eslint/prefer-optional-chain -- false positive
 			if (!(fileName && siteURL && driveID && filePath !== null && filePath !== undefined)) {
 				throw new NonRetryableError(
 					"Proper new file params should be there!!",

package/src/odspDriverUrlResolverForShareLink.ts

@@ -30,6 +30,7 @@ import { getFileLink } from "./getFileLink";
 
 /**
  * Properties passed to the code responsible for fetching share link for a file.
+ * @public
  */
 export interface ShareLinkFetcherProps {
 	/**
@@ -46,6 +47,7 @@ export interface ShareLinkFetcherProps {
  * Resolver to resolve urls like the ones created by createOdspUrl which is driver inner
  * url format and the ones which have things like driveId, siteId, itemId etc encoded in nav param.
  * This resolver also handles share links and try to generate one for the use by the app.
+ * @public
  */
 export class OdspDriverUrlResolverForShareLink implements IUrlResolver {
 	private readonly logger: ITelemetryLoggerExt;

package/src/odspFluidFileLink.ts

@@ -22,6 +22,7 @@ const additionalContextParamName = "x";
  * Transforms given Fluid data store locator into string that can be embedded into url
  * @param locator - describes Fluid data store locator info to be encoded
  * @returns string representing encoded Fluid data store locator info
+ * @public
  */
 export function encodeOdspFluidDataStoreLocator(locator: OdspFluidDataStoreLocator): string {
 	const siteUrl = new URL(locator.siteUrl);
@@ -56,16 +57,18 @@ export function encodeOdspFluidDataStoreLocator(locator: OdspFluidDataStoreLocat
  * @param encodedLocatorValue - encoded Fluid data store locator value which was produced by
  * {@link encodeOdspFluidDataStoreLocator} function
  * @param siteOriginUrl - site origin that will be appended to encoded relative path to form absolute file url
+ * @param requireFluidSignature - flag representing if the Fluid signature is expected in the url, default true
  * @returns object representing Fluid data store location in ODSP terms
  */
 function decodeOdspFluidDataStoreLocator(
 	encodedLocatorValue: string,
 	siteOriginUrl: string,
+	requireFluidSignature: boolean = true,
 ): OdspFluidDataStoreLocator | undefined {
 	const locatorInfo = new URLSearchParams(fromBase64ToUtf8(encodedLocatorValue));
 
 	const signatureValue = locatorInfo.get(fluidSignatureParamName);
-	if (signatureValue !== "1") {
+	if (requireFluidSignature && signatureValue !== "1") {
 		return undefined;
 	}
 
@@ -106,14 +109,18 @@ function decodeOdspFluidDataStoreLocator(
 	};
 }
 
-// This parameter is provided by host in the resolve request and it contains information about the file
-// like driveId, itemId, siteUrl, datastorePath, packageName etc.
+/**
+ * This parameter is provided by host in the resolve request and it contains information about the file
+ * like driveId, itemId, siteUrl, datastorePath, packageName etc.
+ * @public
+ */
 export const locatorQueryParamName = "nav";
 
 /**
  * Embeds Fluid data store locator data into given ODSP url
  * @param url - file url in ODSP format (can be either canonical or share link)
  * @param locator - object representing Fluid data store location in ODSP terms
+ * @public
  */
 export function storeLocatorInOdspUrl(url: URL, locator: OdspFluidDataStoreLocator) {
 	const encodedLocatorValue = encodeOdspFluidDataStoreLocator(locator);
@@ -126,9 +133,14 @@ export function storeLocatorInOdspUrl(url: URL, locator: OdspFluidDataStoreLocat
  * Extract ODSP Fluid data store locator object from given ODSP url. This extracts things like
  * driveId, ItemId, siteUrl etc from a url where these are encoded in nav query param.
  * @param url - ODSP url representing Fluid file link
+ * @param requireFluidSignature - flag representing if the Fluid signature is expected in the url, default true
  * @returns object representing Fluid data store location in ODSP terms
+ * @public
  */
-export function getLocatorFromOdspUrl(url: URL): OdspFluidDataStoreLocator | undefined {
+export function getLocatorFromOdspUrl(
+	url: URL,
+	requireFluidSignature: boolean = true,
+): OdspFluidDataStoreLocator | undefined {
 	// NOTE: No need to apply decodeURIComponent when accessing query params via URLSearchParams class.
 	const encodedLocatorValue = url.searchParams.get(locatorQueryParamName);
 	if (!encodedLocatorValue) {
@@ -140,5 +152,9 @@ export function getLocatorFromOdspUrl(url: URL): OdspFluidDataStoreLocator | und
 	const siteOriginUrl =
 		url.origin.toLowerCase() === OdcFileSiteOrigin ? OdcApiSiteOrigin : url.origin;
 
-	return decodeOdspFluidDataStoreLocator(encodedLocatorValue, siteOriginUrl);
+	return decodeOdspFluidDataStoreLocator(
+		encodedLocatorValue,
+		siteOriginUrl,
+		requireFluidSignature,
+	);
 }

package/src/odspPublicUtils.ts

@@ -6,11 +6,17 @@
 import { hashFile, IsoBuffer } from "@fluid-internal/client-utils";
 import { ISequencedDocumentMessage, ISnapshotTree } from "@fluidframework/protocol-definitions";
 
+/**
+ * @public
+ */
 export async function getHashedDocumentId(driveId: string, itemId: string): Promise<string> {
 	const buffer = IsoBuffer.from(`${driveId}_${itemId}`);
 	return encodeURIComponent(await hashFile(buffer, "SHA-256", "base64"));
 }
 
+/**
+ * @public
+ */
 export interface ISnapshotContents {
 	snapshotTree: ISnapshotTree;
 	blobs: Map<string, ArrayBuffer>;

package/src/odspUrlHelper.ts

@@ -10,6 +10,7 @@ import { IOdspUrlParts } from "@fluidframework/odsp-driver-definitions";
 /**
  * Checks whether or not the given URL origin is an ODC origin
  * @param origin - The URL origin to check
+ * @public
  */
 export function isOdcOrigin(origin: string): boolean {
 	return (
@@ -27,6 +28,7 @@ export function isOdcOrigin(origin: string): boolean {
 /**
  * Gets the correct API root for the given ODSP url, e.g. 'https://foo-my.sharepoint.com/_api/v2.1'
  * @param origin - The URL origin
+ * @public
  */
 export function getApiRoot(origin: string): string {
 	let prefix = "_api/";
@@ -40,6 +42,7 @@ export function getApiRoot(origin: string): string {
 /**
  * Whether or not the given URL is a valid SPO/ODB URL
  * @param url - The URL to check
+ * @public
  */
 export function isSpoUrl(url: string): boolean {
 	const urlLower = url.toLowerCase();
@@ -52,6 +55,7 @@ export function isSpoUrl(url: string): boolean {
 /**
  * Whether or not the given URL is a valid ODC URL
  * @param url - The URL to check
+ * @public
  */
 export function isOdcUrl(url: string | URL): boolean {
 	const urlObj = typeof url === "string" ? new URL(url) : url;
@@ -76,6 +80,7 @@ export function isOdcUrl(url: string | URL): boolean {
  * Breaks an ODSP URL into its parts, extracting the site, drive ID, and item ID.
  * Returns undefined for invalid/malformed URLs.
  * @param url - The (raw) URL to parse
+ * @public
  */
 export async function getOdspUrlParts(url: URL): Promise<IOdspUrlParts | undefined> {
 	const pathname = url.pathname;

package/src/odspUtils.ts

@@ -50,6 +50,9 @@ export const getWithRetryForTokenRefreshRepeat = "getWithRetryForTokenRefreshRep
 /** Parse the given url and return the origin (host name) */
 export const getOrigin = (url: string) => new URL(url).origin;
 
+/**
+ * @public
+ */
 export interface IOdspResponse<T> {
 	content: T;
 	headers: Map<string, string>;
@@ -441,6 +444,7 @@ export function buildOdspShareLinkReqParams(
 	}
 	const scope = (shareLinkType as ISharingLinkKind).scope;
 	if (!scope) {
+		// eslint-disable-next-line @typescript-eslint/no-base-to-string
 		return `createLinkType=${shareLinkType}`;
 	}
 	let shareLinkRequestParams = `createLinkScope=${scope}`;

package/src/opsCaching.ts

@@ -65,7 +65,14 @@ export class OpsCache {
 
 	public flushOps() {
 		for (const [key, value] of this.batches) {
-			if (value === null || !value.dirty) {
+			// Don't flush if the batch has no ops, already flushed or has empty slots at both beginning and end.
+			if (
+				value === null ||
+				!value.dirty ||
+				value.batchData.length === 0 ||
+				(value.batchData[0] === undefined &&
+					value.batchData[value.batchData.length - 1] === undefined)
+			) {
 				continue;
 			}
 			value.dirty = false;
@@ -138,6 +145,7 @@ export class OpsCache {
 				return messages;
 			}
 			const result: CacheEntry = JSON.parse(res);
+			const prevMessagesLength = messages.length;
 			for (const op of result) {
 				// Note that we write out undefined, but due to JSON.stringify, it turns into null!
 				if (op) {
@@ -153,10 +161,16 @@ export class OpsCache {
 					}
 					messages.push(op);
 				} else if (messages.length !== 0) {
+					// If there is any gap, return the messages till now.
 					return messages;
 				}
 			}
 
+			// If we didn't get any op from this batch, then return messages till now. As it tells us that,
+			// either the first message "from" is not present in cache or a gap will occur from 1 batch to next.
+			if (prevMessagesLength === messages.length) {
+				return messages;
+			}
 			batchNumber++;
 		}
 	}

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/odsp-driver";
-export const pkgVersion = "2.0.0-dev.6.4.0.192049";
+export const pkgVersion = "2.0.0-dev.7.2.0.203917";

package/src/prefetchLatestSnapshot.ts

@@ -52,6 +52,8 @@ import { OdspDocumentServiceFactory } from "./odspDocumentServiceFactory";
  * @param odspDocumentServiceFactory - factory to access the non persistent cache and store the prefetch promise.
  *
  * @returns `true` if the snapshot is cached, `false` otherwise.
+ *
+ * @public
  */
 export async function prefetchLatestSnapshot(
 	resolvedUrl: IResolvedUrl,

package/src/socketModule.ts

@@ -0,0 +1,8 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { io } from "socket.io-client";
+
+export const SocketIOClientStatic = io;

package/src/zipItDataRepresentationUtils.ts

@@ -206,7 +206,11 @@ export class BlobShallowCopy extends BlobCore {
 	 * @param start - Start point of the blob in the buffer.
 	 * @param end - End point of the blob in the buffer.
 	 */
-	constructor(protected data: Uint8Array, protected start: number, protected end: number) {
+	constructor(
+		protected data: Uint8Array,
+		protected start: number,
+		protected end: number,
+	) {
 		super();
 	}