@fluidframework/routerlicious-driver 2.0.0-internal.3.0.5 → 2.0.0-internal.3.1.1

package/src/deltaStorageService.ts

@@ -4,10 +4,10 @@
  */
 
 import {
-    IDeltaStorageService,
-    IDocumentDeltaStorageService,
-    IDeltasFetchResult,
-    IStream,
+	IDeltaStorageService,
+	IDocumentDeltaStorageService,
+	IDeltasFetchResult,
+	IStream,
 } from "@fluidframework/driver-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
 import { readAndParse, requestOps, emptyMessageStream } from "@fluidframework/driver-utils";
@@ -22,108 +22,112 @@ const MaxBatchDeltas = 2000; // Maximum number of ops we can fetch at a time
  * Storage service limited to only being able to fetch documents for a specific document
  */
 export class DocumentDeltaStorageService implements IDocumentDeltaStorageService {
-    constructor(
-        private readonly tenantId: string,
-        private readonly id: string,
-        private readonly deltaStorageService: IDeltaStorageService,
-        private readonly documentStorageService: DocumentStorageService,
-        private readonly logger: ITelemetryLogger) {
-    }
+	constructor(
+		private readonly tenantId: string,
+		private readonly id: string,
+		private readonly deltaStorageService: IDeltaStorageService,
+		private readonly documentStorageService: DocumentStorageService,
+		private readonly logger: ITelemetryLogger,
+	) {}
 
-    private logtailSha: string | undefined = this.documentStorageService.logTailSha;
+	private logtailSha: string | undefined = this.documentStorageService.logTailSha;
 
-    fetchMessages(from: number,
-        to: number | undefined,
-        abortSignal?: AbortSignal,
-        cachedOnly?: boolean,
-        fetchReason?: string,
-    ): IStream<ISequencedDocumentMessage[]> {
-        if (cachedOnly) {
-            return emptyMessageStream;
-        }
-        return requestOps(
-            this.getCore.bind(this),
-            // Staging: starting with no concurrency, listening for feedback first.
-            // In future releases we will switch to actual concurrency
-            1, // concurrency
-            from, // inclusive
-            to, // exclusive
-            MaxBatchDeltas,
-            new TelemetryNullLogger(),
-            abortSignal,
-            fetchReason,
-        );
-    }
+	fetchMessages(
+		from: number,
+		to: number | undefined,
+		abortSignal?: AbortSignal,
+		cachedOnly?: boolean,
+		fetchReason?: string,
+	): IStream<ISequencedDocumentMessage[]> {
+		if (cachedOnly) {
+			return emptyMessageStream;
+		}
+		return requestOps(
+			this.getCore.bind(this),
+			// Staging: starting with no concurrency, listening for feedback first.
+			// In future releases we will switch to actual concurrency
+			1, // concurrency
+			from, // inclusive
+			to, // exclusive
+			MaxBatchDeltas,
+			new TelemetryNullLogger(),
+			abortSignal,
+			fetchReason,
+		);
+	}
 
-    private async getCore(from: number, to: number): Promise<IDeltasFetchResult> {
-        const opsFromLogTail = this.logtailSha
-            ? await readAndParse<ISequencedDocumentMessage[]>(this.documentStorageService, this.logtailSha)
-            : [];
+	private async getCore(from: number, to: number): Promise<IDeltasFetchResult> {
+		const opsFromLogTail = this.logtailSha
+			? await readAndParse<ISequencedDocumentMessage[]>(
+					this.documentStorageService,
+					this.logtailSha,
+			  )
+			: [];
 
-        this.logtailSha = undefined;
-        if (opsFromLogTail.length > 0) {
-            try {
-                const messages = opsFromLogTail.filter((op, i) => {
-                    // throw if the sequence numbers in logtail are not contiguous
-                    if (i > 0 && op.sequenceNumber !== opsFromLogTail[i - 1].sequenceNumber + 1) {
-                        throw new Error("Log tail ops are not contiguous");
-                    }
-                    return op.sequenceNumber >= from;
-                });
-                
-                if (messages.length > 0 && messages[0].sequenceNumber === from) {
-                    return { messages, partialResult: true };
-                }     
-            } catch (error) {
-                this.logger.sendErrorEvent({ eventName: "LogTailReadError" }, error);
-            }
-        }
+		this.logtailSha = undefined;
+		if (opsFromLogTail.length > 0) {
+			try {
+				const messages = opsFromLogTail.filter((op, i) => {
+					// throw if the sequence numbers in logtail are not contiguous
+					if (i > 0 && op.sequenceNumber !== opsFromLogTail[i - 1].sequenceNumber + 1) {
+						throw new Error("Log tail ops are not contiguous");
+					}
+					return op.sequenceNumber >= from;
+				});
 
-        return this.deltaStorageService.get(this.tenantId, this.id, from, to);
-    }
+				if (messages.length > 0 && messages[0].sequenceNumber === from) {
+					return { messages, partialResult: true };
+				}
+			} catch (error) {
+				this.logger.sendErrorEvent({ eventName: "LogTailReadError" }, error);
+			}
+		}
+
+		return this.deltaStorageService.get(this.tenantId, this.id, from, to);
+	}
 }
 
 /**
  * Provides access to the underlying delta storage on the server for routerlicious driver.
  */
 export class DeltaStorageService implements IDeltaStorageService {
-    constructor(
-        private readonly url: string,
-        private readonly restWrapper: RestWrapper,
-        private readonly logger: ITelemetryLogger,
-        private readonly getRestWrapper: () => Promise<RestWrapper> = async () => this.restWrapper,
-        private readonly getDeltaStorageUrl: () => string = () => this.url,
-    ) {
-    }
+	constructor(
+		private readonly url: string,
+		private readonly restWrapper: RestWrapper,
+		private readonly logger: ITelemetryLogger,
+		private readonly getRestWrapper: () => Promise<RestWrapper> = async () => this.restWrapper,
+		private readonly getDeltaStorageUrl: () => string = () => this.url,
+	) {}
 
-    public async get(
-        tenantId: string,
-        id: string,
-        from: number, // inclusive
-        to: number, // exclusive
-    ): Promise<IDeltasFetchResult> {
-        const ops = await PerformanceEvent.timedExecAsync(
-            this.logger,
-            {
-                eventName: "getDeltas",
-                from,
-                to,
-            },
-            async (event) => {
-                const restWrapper = await this.getRestWrapper();
-                const url = this.getDeltaStorageUrl();
-                const response = await restWrapper.get<ISequencedDocumentMessage[]>(
-                    url,
-                    { from: from - 1, to });
-                event.end({
-                    count: response.length,
-                });
-                return response;
-            },
-        );
+	public async get(
+		tenantId: string,
+		id: string,
+		from: number, // inclusive
+		to: number, // exclusive
+	): Promise<IDeltasFetchResult> {
+		const ops = await PerformanceEvent.timedExecAsync(
+			this.logger,
+			{
+				eventName: "getDeltas",
+				from,
+				to,
+			},
+			async (event) => {
+				const restWrapper = await this.getRestWrapper();
+				const url = this.getDeltaStorageUrl();
+				const response = await restWrapper.get<ISequencedDocumentMessage[]>(url, {
+					from: from - 1,
+					to,
+				});
+				event.end({
+					count: response.length,
+				});
+				return response;
+			},
+		);
 
-        // It is assumed that server always returns all the ops that it has in the range that was requested.
-        // This may change in the future, if so, we need to adjust and receive "end" value from server in such case.
-        return { messages: ops, partialResult: false };
-    }
+		// It is assumed that server always returns all the ops that it has in the range that was requested.
+		// This may change in the future, if so, we need to adjust and receive "end" value from server in such case.
+		return { messages: ops, partialResult: false };
+	}
 }

package/src/documentDeltaConnection.ts

@@ -17,55 +17,61 @@ const protocolVersions = ["^0.4.0", "^0.3.0", "^0.2.0", "^0.1.0"];
  * Wrapper over the shared one for driver specific translation.
  */
 export class R11sDocumentDeltaConnection extends DocumentDeltaConnection {
-    public static async create(
-        tenantId: string,
-        id: string,
-        token: string | null,
-        io: typeof SocketIOClientStatic,
-        client: IClient,
-        url: string,
-        logger: ITelemetryLogger,
-        timeoutMs = 20000): Promise<IDocumentDeltaConnection> {
-        const socket = io(
-            url,
-            {
-                query: {
-                    documentId: id,
-                    tenantId,
-                },
-                reconnection: false,
-                // Default to websocket connection, with long-polling disabled
-                transports: ["websocket"],
-                timeout: timeoutMs,
-            });
+	public static async create(
+		tenantId: string,
+		id: string,
+		token: string | null,
+		io: typeof SocketIOClientStatic,
+		client: IClient,
+		url: string,
+		logger: ITelemetryLogger,
+		timeoutMs = 20000,
+	): Promise<IDocumentDeltaConnection> {
+		const socket = io(url, {
+			query: {
+				documentId: id,
+				tenantId,
+			},
+			reconnection: false,
+			// Default to websocket connection, with long-polling disabled
+			transports: ["websocket"],
+			timeout: timeoutMs,
+		});
 
-        const connectMessage: IConnect = {
-            client,
-            id,
-            mode: client.mode,
-            tenantId,
-            token,  // Token is going to indicate tenant level information, etc...
-            versions: protocolVersions,
-            relayUserAgent: [client.details.environment, ` driverVersion:${driverVersion}`].join(";"),
-        };
+		const connectMessage: IConnect = {
+			client,
+			id,
+			mode: client.mode,
+			tenantId,
+			token, // Token is going to indicate tenant level information, etc...
+			versions: protocolVersions,
+			relayUserAgent: [client.details.environment, ` driverVersion:${driverVersion}`].join(
+				";",
+			),
+		};
 
-        // TODO: expose to host at factory level
-        const enableLongPollingDowngrades = true;
-        const deltaConnection = new R11sDocumentDeltaConnection(socket, id, logger, enableLongPollingDowngrades);
+		// TODO: expose to host at factory level
+		const enableLongPollingDowngrades = true;
+		const deltaConnection = new R11sDocumentDeltaConnection(
+			socket,
+			id,
+			logger,
+			enableLongPollingDowngrades,
+		);
 
-        await deltaConnection.initialize(connectMessage, timeoutMs);
-        return deltaConnection;
-    }
+		await deltaConnection.initialize(connectMessage, timeoutMs);
+		return deltaConnection;
+	}
 
-    /**
-     * Error raising for socket.io issues
-     */
-    protected createErrorObject(handler: string, error?: any, canRetry = true): IAnyDriverError {
-        // Note: we suspect the incoming error object is either:
-        // - a socketError: add it to the R11sError object for driver to be able to parse it and reason over it.
-        // - anything else: let base class handle it
-        return canRetry && Number.isInteger(error?.code) && typeof error?.message === "string"
-            ? errorObjectFromSocketError(error as IR11sSocketError, handler)
-            : super.createErrorObject(handler, error, canRetry);
-    }
+	/**
+	 * Error raising for socket.io issues
+	 */
+	protected createErrorObject(handler: string, error?: any, canRetry = true): IAnyDriverError {
+		// Note: we suspect the incoming error object is either:
+		// - a socketError: add it to the R11sError object for driver to be able to parse it and reason over it.
+		// - anything else: let base class handle it
+		return canRetry && Number.isInteger(error?.code) && typeof error?.message === "string"
+			? errorObjectFromSocketError(error as IR11sSocketError, handler)
+			: super.createErrorObject(handler, error, canRetry);
+	}
 }