@fluidframework/container-loader 2.0.0-dev.3.1.0.125672 → 2.0.0-dev.4.2.0.153917

package/src/loader.ts

@@ -36,15 +36,10 @@ import {
 	IDocumentServiceFactory,
 	IDocumentStorageService,
 	IFluidResolvedUrl,
-	IResolvedUrl,
 	IUrlResolver,
 } from "@fluidframework/driver-definitions";
 import { ISequencedDocumentMessage } from "@fluidframework/protocol-definitions";
-import {
-	ensureFluidResolvedUrl,
-	MultiUrlResolver,
-	MultiDocumentServiceFactory,
-} from "@fluidframework/driver-utils";
+import { ensureFluidResolvedUrl } from "@fluidframework/driver-utils";
 import { Container, IPendingContainerState } from "./container";
 import { IParsedUrl, parseUrl } from "./utils";
 import { pkgVersion } from "./packageVersion";
@@ -58,6 +53,9 @@ function canUseCache(request: IRequest): boolean {
 	return request.headers[LoaderHeader.cache] !== false;
 }
 
+/**
+ * @deprecated - In the next release RelativeLoader will no longer be exported. It is an internal class that should not be used directly.
+ */
 export class RelativeLoader implements ILoader {
 	constructor(
 		private readonly container: Container,
@@ -109,22 +107,6 @@ export class RelativeLoader implements ILoader {
 	}
 }
 
-function createCachedResolver(resolver: IUrlResolver) {
-	const cacheResolver = Object.create(resolver) as IUrlResolver;
-	const resolveCache = new Map<string, Promise<IResolvedUrl | undefined>>();
-	cacheResolver.resolve = async (request: IRequest): Promise<IResolvedUrl | undefined> => {
-		if (!canUseCache(request)) {
-			return resolver.resolve(request);
-		}
-		if (!resolveCache.has(request.url)) {
-			resolveCache.set(request.url, resolver.resolve(request));
-		}
-
-		return resolveCache.get(request.url);
-	};
-	return cacheResolver;
-}
-
 export interface ILoaderOptions extends ILoaderOptions1 {
 	summarizeProtocolTree?: boolean;
 }
@@ -275,6 +257,31 @@ export type IDetachedBlobStorage = Pick<IDocumentStorageService, "createBlob" |
 	getBlobIds(): string[];
 };
 
+/**
+ * With an already-resolved container, we can request a component directly, without loading the container again
+ * @param container - a resolved container
+ * @returns component on the container
+ */
+export async function requestResolvedObjectFromContainer(
+	container: IContainer,
+	headers?: IRequestHeader,
+): Promise<IResponse> {
+	ensureFluidResolvedUrl(container.resolvedUrl);
+	const parsedUrl = parseUrl(container.resolvedUrl.url);
+
+	if (parsedUrl === undefined) {
+		throw new Error(`Invalid URL ${container.resolvedUrl.url}`);
+	}
+
+	const entryPoint: FluidObject<IFluidRouter> | undefined = await container.getEntryPoint?.();
+	const router = entryPoint?.IFluidRouter ?? container.IFluidRouter;
+
+	return router.request({
+		url: `${parsedUrl.path}${parsedUrl.query}`,
+		headers,
+	});
+}
+
 /**
  * Manages Fluid resource loading
  */
@@ -303,10 +310,8 @@ export class Loader implements IHostLoader {
 		);
 
 		this.services = {
-			urlResolver: createCachedResolver(MultiUrlResolver.create(loaderProps.urlResolver)),
-			documentServiceFactory: MultiDocumentServiceFactory.create(
-				loaderProps.documentServiceFactory,
-			),
+			urlResolver: loaderProps.urlResolver,
+			documentServiceFactory: loaderProps.documentServiceFactory,
 			codeLoader: loaderProps.codeLoader,
 			options: loaderProps.options ?? {},
 			scope,

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/container-loader";
-export const pkgVersion = "2.0.0-dev.3.1.0.125672";
+export const pkgVersion = "2.0.0-dev.4.2.0.153917";

package/src/protocol.ts

@@ -20,6 +20,9 @@ import {
 } from "@fluidframework/protocol-definitions";
 import { canBeCoalescedByService } from "@fluidframework/driver-utils";
 
+// "term" was an experimental feature that is being removed.  The only safe value to use is 1.
+export const OnlyValidTermValue = 1 as const;
+
 // ADO: #1986: Start using enum from protocol-base.
 export enum SignalType {
 	ClientJoin = "join", // same value as MessageType.ClientJoin,
@@ -51,7 +54,7 @@ export class ProtocolHandler extends ProtocolOpHandler implements IProtocolHandl
 		super(
 			attributes.minimumSequenceNumber,
 			attributes.sequenceNumber,
-			attributes.term,
+			OnlyValidTermValue,
 			quorumSnapshot.members,
 			quorumSnapshot.proposals,
 			quorumSnapshot.values,

package/src/protocolTreeDocumentStorageService.ts

@@ -5,13 +5,16 @@
 
 import { IDisposable } from "@fluidframework/common-definitions";
 import { IDocumentStorageService, ISummaryContext } from "@fluidframework/driver-definitions";
-import { combineAppAndProtocolSummary } from "@fluidframework/driver-utils";
 import { ISummaryTree } from "@fluidframework/protocol-definitions";
 
+/**
+ * A storage service wrapper whose sole job is to intercept calls to uploadSummaryWithContext and ensure they include
+ * the protocol summary, using the provided callback to add it if necessary.
+ */
 export class ProtocolTreeStorageService implements IDocumentStorageService, IDisposable {
 	constructor(
 		private readonly internalStorageService: IDocumentStorageService & IDisposable,
-		private readonly generateProtocolTree: () => ISummaryTree,
+		private readonly addProtocolSummaryIfMissing: (summaryTree: ISummaryTree) => ISummaryTree,
 	) {}
 	public get policies() {
 		return this.internalStorageService.policies;
@@ -35,7 +38,7 @@ export class ProtocolTreeStorageService implements IDocumentStorageService, IDis
 		context: ISummaryContext,
 	): Promise<string> {
 		return this.internalStorageService.uploadSummaryWithContext(
-			combineAppAndProtocolSummary(summary, this.generateProtocolTree()),
+			this.addProtocolSummaryIfMissing(summary),
 			context,
 		);
 	}

package/src/utils.ts

@@ -13,6 +13,7 @@ import {
 } from "@fluidframework/common-utils";
 import { ISummaryTree, ISnapshotTree, SummaryType } from "@fluidframework/protocol-definitions";
 import { LoggingError } from "@fluidframework/telemetry-utils";
+import { isCombinedAppAndProtocolSummary } from "@fluidframework/driver-utils";
 
 // This is used when we rehydrate a container from the snapshot. Here we put the blob contents
 // in separate property: blobContents.
@@ -125,13 +126,15 @@ export function convertProtocolAndAppSummaryToSnapshotTree(
 
 // This function converts the snapshot taken in detached container(by serialize api) to snapshotTree with which
 // a detached container can be rehydrated.
-export const getSnapshotTreeFromSerializedContainer = (detachedContainerSnapshot: ISummaryTree) => {
-	const protocolSummaryTree = detachedContainerSnapshot.tree[".protocol"] as ISummaryTree;
-	const appSummaryTree = detachedContainerSnapshot.tree[".app"] as ISummaryTree;
+export const getSnapshotTreeFromSerializedContainer = (
+	detachedContainerSnapshot: ISummaryTree,
+): ISnapshotTreeWithBlobContents => {
 	assert(
-		protocolSummaryTree !== undefined && appSummaryTree !== undefined,
+		isCombinedAppAndProtocolSummary(detachedContainerSnapshot),
 		0x1e0 /* "Protocol and App summary trees should be present" */,
 	);
+	const protocolSummaryTree = detachedContainerSnapshot.tree[".protocol"];
+	const appSummaryTree = detachedContainerSnapshot.tree[".app"];
 	const snapshotTreeWithBlobContents = convertProtocolAndAppSummaryToSnapshotTree(
 		protocolSummaryTree,
 		appSummaryTree,