@fluidframework/driver-utils 1.4.0-121020 → 2.0.0-dev-rc.1.0.0.224419

package/src/insecureUrlResolver.ts

@@ -4,14 +4,9 @@
  */
 
 import { parse } from "url";
-import { assert } from "@fluidframework/common-utils";
+import { assert } from "@fluidframework/core-utils";
 import { IRequest } from "@fluidframework/core-interfaces";
-import {
-    IFluidResolvedUrl,
-    IResolvedUrl,
-    IUrlResolver,
-    DriverHeader,
-} from "@fluidframework/driver-definitions";
+import { IResolvedUrl, IUrlResolver, DriverHeader } from "@fluidframework/driver-definitions";
 import Axios from "axios";
 
 /**
@@ -27,130 +22,140 @@ import Axios from "axios";
  * The tenantId/documentId pair defines the 'full' document ID the service makes use of. The path is then an optional
  * part of the URL that the document interprets and maps to a data store. It's exactly similar to how a web service
  * works or a router inside of a single page app framework.
+ * @internal
  */
 export class InsecureUrlResolver implements IUrlResolver {
-    private readonly cache = new Map<string, Promise<IResolvedUrl>>();
+	private readonly cache = new Map<string, Promise<IResolvedUrl>>();
 
-    constructor(
-        private readonly hostUrl: string,
-        private readonly ordererUrl: string,
-        private readonly storageUrl: string,
-        private readonly tenantId: string,
-        private readonly bearer: string,
-        private readonly isForNodeTest: boolean = false,
-    ) { }
+	constructor(
+		private readonly hostUrl: string,
+		private readonly ordererUrl: string,
+		private readonly storageUrl: string,
+		private readonly tenantId: string,
+		private readonly bearer: string,
+		private readonly isForNodeTest: boolean = false,
+	) {}
 
-    public async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (request.headers?.[DriverHeader.createNew]) {
-            const [, queryString] = request.url.split("?");
-            const searchParams = new URLSearchParams(queryString);
-            const fileName = searchParams.get("fileName");
-            return this.resolveHelper(fileName);
-        }
-        const parsedUrl = new URL(request.url);
-        // If hosts match then we use the local tenant information. Otherwise we make a REST call out to the hosting
-        // service using our bearer token.
-        if (this.isForNodeTest) {
-            const [, documentId, tmpRelativePath] = parsedUrl.pathname.substr(1).split("/");
-            const relativePath = tmpRelativePath === undefined ? "" : tmpRelativePath;
-            return this.resolveHelper(documentId, relativePath, parsedUrl.search);
-        } else if (parsedUrl.host === window.location.host) {
-            const fullPath = parsedUrl.pathname.substr(1);
-            const documentId = fullPath.split("/")[0];
-            const documentRelativePath = fullPath.slice(documentId.length);
-            return this.resolveHelper(documentId, documentRelativePath);
-        } else {
-            const maybeResolvedUrl = this.cache.get(request.url);
-            if (maybeResolvedUrl) {
-                return maybeResolvedUrl;
-            }
+	public async resolve(request: IRequest): Promise<IResolvedUrl | undefined> {
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		if (request.headers?.[DriverHeader.createNew]) {
+			const [, queryString] = request.url.split("?");
+			const searchParams = new URLSearchParams(queryString);
+			const fileName = searchParams.get("fileName");
+			return this.resolveHelper(fileName);
+		}
+		const parsedUrl = new URL(request.url);
+		// If hosts match then we use the local tenant information. Otherwise we make a REST call out to the hosting
+		// service using our bearer token.
+		if (this.isForNodeTest) {
+			const [, documentId, tmpRelativePath] = parsedUrl.pathname.substr(1).split("/");
+			const relativePath = tmpRelativePath ?? "";
+			return this.resolveHelper(documentId, relativePath, parsedUrl.search);
+		} else if (parsedUrl.host === window.location.host) {
+			const fullPath = parsedUrl.pathname.substr(1);
+			const documentId = fullPath.split("/")[0];
+			const documentRelativePath = fullPath.slice(documentId.length);
+			return this.resolveHelper(documentId, documentRelativePath);
+		} else {
+			const maybeResolvedUrl = this.cache.get(request.url);
+			if (maybeResolvedUrl) {
+				return maybeResolvedUrl;
+			}
 
-            const headers = {
-                Authorization: `Bearer ${this.bearer}`,
-            };
-            const resolvedP = Axios.post<IResolvedUrl>(
-                `${this.hostUrl}/api/v1/load`,
-                {
-                    url: request.url,
-                },
-                {
-                    headers,
-                });
-            this.cache.set(request.url, resolvedP.then((resolved) => resolved.data));
+			const headers = {
+				Authorization: `Bearer ${this.bearer}`,
+			};
+			const resolvedP = Axios.post<IResolvedUrl>(
+				`${this.hostUrl}/api/v1/load`,
+				{
+					url: request.url,
+				},
+				{
+					headers,
+				},
+			);
+			this.cache.set(
+				request.url,
+				resolvedP.then((resolved) => resolved.data),
+			);
 
-            return this.cache.get(request.url);
-        }
-    }
+			return this.cache.get(request.url);
+		}
+	}
 
-    private resolveHelper(documentId: string | null, documentRelativePath: string = "", queryParams: string = "") {
-        const encodedTenantId = encodeURIComponent(this.tenantId);
-        const host = new URL(this.ordererUrl).host;
-        // when the document ID is not provided we need to resolve a special create new document URL.
-        // the actual container ID will be generated by the driver.
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        if (!documentId) {
-            const createNewResponse: IFluidResolvedUrl = {
-                endpoints: {
-                    deltaStorageUrl: `${this.ordererUrl}/deltas/${encodedTenantId}/new`,
-                    ordererUrl: this.ordererUrl,
-                    storageUrl: `${this.storageUrl}/repos/${encodedTenantId}`,
-                },
-                // document ID is ignored by the driver for new container requests
-                id: "",
-                tokens: {},
-                type: "fluid",
-                url: `fluid://${host}/${encodedTenantId}/new`,
-            };
-            return createNewResponse;
-        }
-        const encodedDocId = encodeURIComponent(documentId);
-        const relativePath = !documentRelativePath || documentRelativePath.startsWith("/")
-            ? documentRelativePath : `/${documentRelativePath}`;
-        const documentUrl = `fluid://${host}/${encodedTenantId}/${encodedDocId}${relativePath}${queryParams}`;
+	private resolveHelper(
+		documentId: string | null,
+		documentRelativePath: string = "",
+		queryParams: string = "",
+	) {
+		const encodedTenantId = encodeURIComponent(this.tenantId);
+		const host = new URL(this.ordererUrl).host;
+		// when the document ID is not provided we need to resolve a special create new document URL.
+		// the actual container ID will be generated by the driver.
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		if (!documentId) {
+			const createNewResponse: IResolvedUrl = {
+				endpoints: {
+					deltaStorageUrl: `${this.ordererUrl}/deltas/${encodedTenantId}/new`,
+					ordererUrl: this.ordererUrl,
+					storageUrl: `${this.storageUrl}/repos/${encodedTenantId}`,
+				},
+				// document ID is ignored by the driver for new container requests
+				id: "",
+				tokens: {},
+				type: "fluid",
+				url: `fluid://${host}/${encodedTenantId}/new`,
+			};
+			return createNewResponse;
+		}
+		const encodedDocId = encodeURIComponent(documentId);
+		const relativePath =
+			!documentRelativePath || documentRelativePath.startsWith("/")
+				? documentRelativePath
+				: `/${documentRelativePath}`;
+		const documentUrl = `fluid://${host}/${encodedTenantId}/${encodedDocId}${relativePath}${queryParams}`;
 
-        const deltaStorageUrl = `${this.ordererUrl}/deltas/${encodedTenantId}/${encodedDocId}`;
-        const storageUrl = `${this.storageUrl}/repos/${encodedTenantId}`;
+		const deltaStorageUrl = `${this.ordererUrl}/deltas/${encodedTenantId}/${encodedDocId}`;
+		const storageUrl = `${this.storageUrl}/repos/${encodedTenantId}`;
 
-        const response: IFluidResolvedUrl = {
-            endpoints: {
-                deltaStorageUrl,
-                ordererUrl: this.ordererUrl,
-                storageUrl,
-            },
-            id: documentId,
-            tokens: {},
-            type: "fluid",
-            url: documentUrl,
-        };
-        return response;
-    }
+		const response: IResolvedUrl = {
+			endpoints: {
+				deltaStorageUrl,
+				ordererUrl: this.ordererUrl,
+				storageUrl,
+			},
+			id: documentId,
+			tokens: {},
+			type: "fluid",
+			url: documentUrl,
+		};
+		return response;
+	}
 
-    public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
-        const fluidResolvedUrl = resolvedUrl as IFluidResolvedUrl;
+	public async getAbsoluteUrl(resolvedUrl: IResolvedUrl, relativeUrl: string): Promise<string> {
+		const parsedUrl = parse(resolvedUrl.url);
+		const [, , documentId] = parsedUrl.pathname?.split("/") ?? [];
+		// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+		assert(!!documentId, 0x273 /* "Invalid document id from parsed URL" */);
 
-        const parsedUrl = parse(fluidResolvedUrl.url);
-        const [, , documentId] = parsedUrl.pathname?.split("/") ?? [];
-        // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-        assert(!!documentId, 0x273 /* "Invalid document id from parsed URL" */);
+		let url = relativeUrl;
+		if (url.startsWith("/")) {
+			url = url.substr(1);
+		}
 
-        let url = relativeUrl;
-        if (url.startsWith("/")) {
-            url = url.substr(1);
-        }
+		return `${this.hostUrl}/${encodeURIComponent(this.tenantId)}/${encodeURIComponent(
+			documentId,
+		)}/${url}`;
+	}
 
-        return `${this.hostUrl}/${encodeURIComponent(
-            this.tenantId)}/${encodeURIComponent(documentId)}/${url}`;
-    }
-
-    public createCreateNewRequest(fileName?: string): IRequest {
-        const createNewRequest: IRequest = {
-            // eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
-            url: fileName ? `${this.hostUrl}?fileName=${fileName}` : this.hostUrl,
-            headers: {
-                [DriverHeader.createNew]: true,
-            },
-        };
-        return createNewRequest;
-    }
+	public createCreateNewRequest(fileName?: string): IRequest {
+		const createNewRequest: IRequest = {
+			// eslint-disable-next-line @typescript-eslint/strict-boolean-expressions
+			url: fileName ? `${this.hostUrl}?fileName=${fileName}` : this.hostUrl,
+			headers: {
+				[DriverHeader.createNew]: true,
+			},
+		};
+		return createNewRequest;
+	}
 }

package/src/messageRecognition.ts

@@ -2,68 +2,39 @@
  * 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";
 
 /**
- *
- * @param message-message
- * @returns whether or not the message type is one listed below
- * "op"
- * "summarize"
- * "propose"
- * "reject"
- * "noop"
+ * 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
+ * @internal
  */
-export function isClientMessage(message: ISequencedDocumentMessage | IDocumentMessage): boolean {
-    if (isRuntimeMessage(message)) {
-        return true;
-    }
-    switch (message.type) {
-        case MessageType.Propose:
-        case MessageType.Reject:
-        case MessageType.NoOp:
-            return true;
-        default:
-            return false;
-    }
+export function isRuntimeMessage(message: { type: string }): boolean {
+	return message.type === MessageType.Operation;
 }
 
 /**
- *
- * @param message-message
- * @returns whether or not the message type is one listed below
- * "op"
- * "summarize"
+ * @privateRemarks ADO #1385: staging code changes across layers.
+ * Eventually to be replaced by MessageType.accept
+ * @internal
  */
-export function isRuntimeMessage(message: ISequencedDocumentMessage | IDocumentMessage): boolean {
-    return message.type === MessageType.Operation || message.type === MessageType.Summarize;
-}
-
-enum RuntimeMessage {
-    FluidDataStoreOp = "component",
-    Attach = "attach",
-    ChunkedOp = "chunkedOp",
-    BlobAttach = "blobAttach",
-    Rejoin = "rejoin",
-    Alias = "alias",
-    Operation = "op",
+export enum MessageType2 {
+	Accept = "accept",
 }
 
 /**
- *
- * @param message-message
- * @returns whether or not the message type is one listed below (legacy)
- * "component"
- * "attach"
- * "chunkedOp"
- * "blobAttach"
- * "rejoin"
- * "alias"
- * "op"
+ * @privateRemarks ADO #1385: To be moved to packages/protocol-base/src/protocol.ts
+ * @internal
  */
-export function isUnpackedRuntimeMessage(message: ISequencedDocumentMessage): boolean {
-    if ((Object.values(RuntimeMessage) as string[]).includes(message.type)) {
-        return true;
-    }
-    return false;
+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;
 }