@fluidframework/runtime-utils 2.0.0-internal.3.0.5 → 2.0.0-internal.3.1.1

package/src/dataStoreHelpers.ts

@@ -5,118 +5,136 @@
 
 import { ITaggedTelemetryPropertyType } from "@fluidframework/common-definitions";
 import { assert } from "@fluidframework/common-utils";
+import { FluidObject, IFluidRouter, IRequest, IResponse } from "@fluidframework/core-interfaces";
 import {
-    FluidObject,
-    IFluidRouter,
-    IRequest,
-    IResponse,
-} from "@fluidframework/core-interfaces";
-import {
-    IFluidDataStoreFactory,
-    IFluidDataStoreRegistry,
-    IProvideFluidDataStoreRegistry,
+	IFluidDataStoreFactory,
+	IFluidDataStoreRegistry,
+	IProvideFluidDataStoreRegistry,
 } from "@fluidframework/runtime-definitions";
 import { generateErrorWithStack, TelemetryDataTag } from "@fluidframework/telemetry-utils";
 
 interface IResponseException extends Error {
-    errorFromRequestFluidObject: true;
-    message: string;
-    code: number;
-    stack?: string;
-    underlyingResponseHeaders?: { [key: string]: any; };
+	errorFromRequestFluidObject: true;
+	message: string;
+	code: number;
+	stack?: string;
+	underlyingResponseHeaders?: { [key: string]: any };
 }
 
 export function exceptionToResponse(err: any): IResponse {
-    const status = 500;
-    if (err !== null && typeof err === "object" && err.errorFromRequestFluidObject === true) {
-        const responseErr: IResponseException = err;
-        return {
-            mimeType: "text/plain",
-            status: responseErr.code,
-            value: responseErr.message,
-            get stack() { return responseErr.stack; },
-            headers: responseErr.underlyingResponseHeaders,
-        };
-    }
-
-    // Capture error objects, not stack itself, as stack retrieval is very expensive operation, so we delay it
-    const errWithStack = generateErrorWithStack();
-
-    return {
-        mimeType: "text/plain",
-        status,
-        value: `${err}`,
-        get stack() { return ((err?.stack) as (string | undefined)) ?? errWithStack.stack; },
-    };
+	const status = 500;
+	if (err !== null && typeof err === "object" && err.errorFromRequestFluidObject === true) {
+		const responseErr: IResponseException = err;
+		return {
+			mimeType: "text/plain",
+			status: responseErr.code,
+			value: responseErr.message,
+			get stack() {
+				return responseErr.stack;
+			},
+			headers: responseErr.underlyingResponseHeaders,
+		};
+	}
+
+	// Capture error objects, not stack itself, as stack retrieval is very expensive operation, so we delay it
+	const errWithStack = generateErrorWithStack();
+
+	return {
+		mimeType: "text/plain",
+		status,
+		value: `${err}`,
+		get stack() {
+			return (err?.stack as string | undefined) ?? errWithStack.stack;
+		},
+	};
 }
 
 export function responseToException(response: IResponse, request: IRequest): Error {
-    const message = response.value;
-    const errWithStack = generateErrorWithStack();
-    const responseErr: Error & IResponseException = {
-        errorFromRequestFluidObject: true,
-        message,
-        name: "Error",
-        code: response.status,
-        get stack() { return response.stack ?? errWithStack.stack; },
-        underlyingResponseHeaders: response.headers,
-    };
-
-    return responseErr;
+	const message = response.value;
+	const errWithStack = generateErrorWithStack();
+	const responseErr: Error & IResponseException = {
+		errorFromRequestFluidObject: true,
+		message,
+		name: "Error",
+		code: response.status,
+		get stack() {
+			return response.stack ?? errWithStack.stack;
+		},
+		underlyingResponseHeaders: response.headers,
+	};
+
+	return responseErr;
 }
 
 /**
  * Takes a set of packages and joins them pkg1/pkg2... etc. Tags the field as a code artifact
  */
 export function packagePathToTelemetryProperty(
-    packagePath: readonly string[] | undefined,
+	packagePath: readonly string[] | undefined,
 ): ITaggedTelemetryPropertyType | undefined {
-    return packagePath ? { value: packagePath.join("/"), tag: TelemetryDataTag.CodeArtifact } : undefined;
+	return packagePath
+		? { value: packagePath.join("/"), tag: TelemetryDataTag.CodeArtifact }
+		: undefined;
 }
 
 export async function requestFluidObject<T = FluidObject>(
-    router: IFluidRouter, url: string | IRequest): Promise<T> {
-    const request = typeof url === "string" ? { url } : url;
-    const response = await router.request(request);
-
-    if (response.status !== 200 || response.mimeType !== "fluid/object") {
-        throw responseToException(response, request);
-    }
-
-    assert(response.value, 0x19a /* "Invalid response value for Fluid object request" */);
-    return response.value as T;
+	router: IFluidRouter,
+	url: string | IRequest,
+): Promise<T> {
+	const request = typeof url === "string" ? { url } : url;
+	const response = await router.request(request);
+
+	if (response.status !== 200 || response.mimeType !== "fluid/object") {
+		throw responseToException(response, request);
+	}
+
+	assert(response.value, 0x19a /* "Invalid response value for Fluid object request" */);
+	return response.value as T;
 }
 
-export const create404Response = (request: IRequest) => createResponseError(404, "not found", request);
-
-export function createResponseError(status: number, value: string, request: IRequest, headers?: { [key: string]: any }): IResponse {
-    assert(status !== 200, 0x19b /* "Cannot not create response error on 200 status" */);
-    // Omit query string which could contain personal data (aka "PII")
-    const urlNoQuery = request.url?.split("?")[0];
-
-    // Capture error objects, not stack itself, as stack retrieval is very expensive operation, so we delay it
-    const errWithStack = generateErrorWithStack();
-
-    return {
-        mimeType: "text/plain",
-        status,
-        value: urlNoQuery === undefined ? value : `${value}: ${urlNoQuery}`,
-        get stack() { return errWithStack.stack; },
-        headers,
-    };
+export const create404Response = (request: IRequest) =>
+	createResponseError(404, "not found", request);
+
+export function createResponseError(
+	status: number,
+	value: string,
+	request: IRequest,
+	headers?: { [key: string]: any },
+): IResponse {
+	assert(status !== 200, 0x19b /* "Cannot not create response error on 200 status" */);
+	// Omit query string which could contain personal data (aka "PII")
+	const urlNoQuery = request.url?.split("?")[0];
+
+	// Capture error objects, not stack itself, as stack retrieval is very expensive operation, so we delay it
+	const errWithStack = generateErrorWithStack();
+
+	return {
+		mimeType: "text/plain",
+		status,
+		value: urlNoQuery === undefined ? value : `${value}: ${urlNoQuery}`,
+		get stack() {
+			return errWithStack.stack;
+		},
+		headers,
+	};
 }
 
 export type Factory = IFluidDataStoreFactory & Partial<IProvideFluidDataStoreRegistry>;
 
 export function createDataStoreFactory(
-    type: string,
-    factory: Factory | Promise<Factory>,
-    ): IFluidDataStoreFactory & IFluidDataStoreRegistry {
-    return {
-        type,
-        get IFluidDataStoreFactory() { return this; },
-        get IFluidDataStoreRegistry() { return this; },
-        instantiateDataStore: async (context, existing) => (await factory).instantiateDataStore(context, existing),
-        get: async (name: string) => (await factory).IFluidDataStoreRegistry?.get(name),
-    };
+	type: string,
+	factory: Factory | Promise<Factory>,
+): IFluidDataStoreFactory & IFluidDataStoreRegistry {
+	return {
+		type,
+		get IFluidDataStoreFactory() {
+			return this;
+		},
+		get IFluidDataStoreRegistry() {
+			return this;
+		},
+		instantiateDataStore: async (context, existing) =>
+			(await factory).instantiateDataStore(context, existing),
+		get: async (name: string) => (await factory).IFluidDataStoreRegistry?.get(name),
+	};
 }

package/src/index.ts

@@ -10,7 +10,7 @@ export {
 	createResponseError,
 	exceptionToResponse,
 	Factory,
-    packagePathToTelemetryProperty,
+	packagePathToTelemetryProperty,
 	requestFluidObject,
 	responseToException,
 } from "./dataStoreHelpers";
@@ -21,7 +21,7 @@ export { RuntimeFactoryHelper } from "./runtimeFactoryHelper";
 export {
 	createRootSummarizerNode,
 	createRootSummarizerNodeWithGC,
-    IFetchSnapshotResult,
+	IFetchSnapshotResult,
 	IRootSummarizerNode,
 	IRootSummarizerNodeWithGC,
 	ISummarizerNodeRootContract,

package/src/objectstoragepartition.ts

@@ -10,20 +10,20 @@ import { IChannelStorageService } from "@fluidframework/datastore-definitions";
  * Returns a new IChannelStorageService that resolves the given `path` as root.
  */
 export class ObjectStoragePartition implements IChannelStorageService {
-    constructor(private readonly storage: IChannelStorageService, private readonly path: string) {
-        // `path` must not include the trailing separator.
-        assert(!path.endsWith("/"), 0x19c /* "storage service path has trailing separator" */);
-    }
+	constructor(private readonly storage: IChannelStorageService, private readonly path: string) {
+		// `path` must not include the trailing separator.
+		assert(!path.endsWith("/"), 0x19c /* "storage service path has trailing separator" */);
+	}
 
-    public async readBlob(path: string): Promise<ArrayBufferLike> {
-        return this.storage.readBlob(`${this.path}/${path}`);
-    }
+	public async readBlob(path: string): Promise<ArrayBufferLike> {
+		return this.storage.readBlob(`${this.path}/${path}`);
+	}
 
-    public async contains(path: string): Promise<boolean> {
-        return this.storage.contains(`${this.path}/${path}`);
-    }
+	public async contains(path: string): Promise<boolean> {
+		return this.storage.contains(`${this.path}/${path}`);
+	}
 
-    public async list(path: string): Promise<string[]> {
-        return this.storage.list(`${this.path}/${path}`);
-    }
+	public async list(path: string): Promise<string[]> {
+		return this.storage.list(`${this.path}/${path}`);
+	}
 }

package/src/objectstorageutils.ts

@@ -6,35 +6,38 @@
 import { ITree } from "@fluidframework/protocol-definitions";
 
 export function getNormalizedObjectStoragePathParts(path: string) {
-    let normalizePath = path;
-    if (normalizePath.startsWith("/")) {
-        normalizePath = normalizePath.substr(1);
-    }
-    if (normalizePath.endsWith("/")) {
-        normalizePath = normalizePath.substr(0, normalizePath.length - 1);
-    }
-    if (normalizePath.length > 0) {
-        return normalizePath.split("/");
-    }
-    return [];
+	let normalizePath = path;
+	if (normalizePath.startsWith("/")) {
+		normalizePath = normalizePath.substr(1);
+	}
+	if (normalizePath.endsWith("/")) {
+		normalizePath = normalizePath.substr(0, normalizePath.length - 1);
+	}
+	if (normalizePath.length > 0) {
+		return normalizePath.split("/");
+	}
+	return [];
 }
 
-export async function listBlobsAtTreePath(inputTree: ITree | undefined, path: string): Promise<string[]> {
-    const pathParts = getNormalizedObjectStoragePathParts(path);
-    let tree: ITree | undefined = inputTree;
-    while (tree?.entries !== undefined && pathParts.length > 0) {
-        const part = pathParts.shift();
-        const treeEntry = tree.entries.find((value) => {
-            return value.type === "Tree" && value.path === part ? true : false;
-        });
+export async function listBlobsAtTreePath(
+	inputTree: ITree | undefined,
+	path: string,
+): Promise<string[]> {
+	const pathParts = getNormalizedObjectStoragePathParts(path);
+	let tree: ITree | undefined = inputTree;
+	while (tree?.entries !== undefined && pathParts.length > 0) {
+		const part = pathParts.shift();
+		const treeEntry = tree.entries.find((value) => {
+			return value.type === "Tree" && value.path === part ? true : false;
+		});
 
-        // this check is largely superfluous due to the same check being done
-        // immediately above. the type system, however, is not aware of this.
-        // so we must redundantly determine that the entry's type is "Tree"
-        tree = treeEntry?.type === "Tree" ? treeEntry.value : undefined;
-    }
-    if (tree?.entries === undefined || pathParts.length !== 0) {
-        throw new Error("path does not exist");
-    }
-    return tree.entries.filter((e) => e.type === "Blob").map((e) => e.path);
+		// this check is largely superfluous due to the same check being done
+		// immediately above. the type system, however, is not aware of this.
+		// so we must redundantly determine that the entry's type is "Tree"
+		tree = treeEntry?.type === "Tree" ? treeEntry.value : undefined;
+	}
+	if (tree?.entries === undefined || pathParts.length !== 0) {
+		throw new Error("path does not exist");
+	}
+	return tree.entries.filter((e) => e.type === "Blob").map((e) => e.path);
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/runtime-utils";
-export const pkgVersion = "2.0.0-internal.3.0.5";
+export const pkgVersion = "2.0.0-internal.3.1.1";

package/src/requestParser.ts

@@ -8,94 +8,92 @@ import { IRequest, IRequestHeader } from "@fluidframework/core-interfaces";
  * The Request Parser takes an IRequest provides parsing and sub request creation
  */
 export class RequestParser implements IRequest {
-    /**
-     * Splits the path of the url and decodes each path part
-     * @param url - the url to get path parts of
-     */
-    public static getPathParts(url: string): readonly string[] {
-        const queryStartIndex = url.indexOf("?");
-        return url
-            .substring(0, queryStartIndex < 0 ? url.length : queryStartIndex)
-            .split("/")
-            .reduce<string[]>(
-                (pv, cv) => {
-                    if (cv !== undefined && cv.length > 0) {
-                        pv.push(decodeURIComponent(cv));
-                    }
-                    return pv;
-                },
-                []);
-    }
+	/**
+	 * Splits the path of the url and decodes each path part
+	 * @param url - the url to get path parts of
+	 */
+	public static getPathParts(url: string): readonly string[] {
+		const queryStartIndex = url.indexOf("?");
+		return url
+			.substring(0, queryStartIndex < 0 ? url.length : queryStartIndex)
+			.split("/")
+			.reduce<string[]>((pv, cv) => {
+				if (cv !== undefined && cv.length > 0) {
+					pv.push(decodeURIComponent(cv));
+				}
+				return pv;
+			}, []);
+	}
 
-    private requestPathParts: readonly string[] | undefined;
-    public readonly query: string;
+	private requestPathParts: readonly string[] | undefined;
+	public readonly query: string;
 
-    public static create(request: Readonly<IRequest>) {
-        // Perf optimizations.
-        if (request instanceof RequestParser) {
-            return request;
-        }
-        return new RequestParser(request);
-    }
+	public static create(request: Readonly<IRequest>) {
+		// Perf optimizations.
+		if (request instanceof RequestParser) {
+			return request;
+		}
+		return new RequestParser(request);
+	}
 
-    protected constructor(private readonly request: Readonly<IRequest>) {
-        const queryStartIndex = this.request.url.indexOf("?");
-        this.query = queryStartIndex >= 0 ? this.request.url.substring(queryStartIndex) : "";
-    }
+	protected constructor(private readonly request: Readonly<IRequest>) {
+		const queryStartIndex = this.request.url.indexOf("?");
+		this.query = queryStartIndex >= 0 ? this.request.url.substring(queryStartIndex) : "";
+	}
 
-    public get url(): string {
-        return this.request.url;
-    }
+	public get url(): string {
+		return this.request.url;
+	}
 
-    public get headers(): IRequestHeader | undefined {
-        return this.request.headers;
-    }
+	public get headers(): IRequestHeader | undefined {
+		return this.request.headers;
+	}
 
-    /**
-     * Returns the decoded path parts of the request's url
-     */
-    public get pathParts(): readonly string[] {
-        if (this.requestPathParts === undefined) {
-            this.requestPathParts = RequestParser.getPathParts(this.url);
-        }
-        return this.requestPathParts;
-    }
+	/**
+	 * Returns the decoded path parts of the request's url
+	 */
+	public get pathParts(): readonly string[] {
+		if (this.requestPathParts === undefined) {
+			this.requestPathParts = RequestParser.getPathParts(this.url);
+		}
+		return this.requestPathParts;
+	}
 
-    /**
-     * Returns true if it's a terminating path, i.e. no more elements after `elements` entries and empty query.
-     * @param elements - number of elements in path
-     */
-    public isLeaf(elements: number) {
-        return this.query === "" && this.pathParts.length === elements;
-    }
+	/**
+	 * Returns true if it's a terminating path, i.e. no more elements after `elements` entries and empty query.
+	 * @param elements - number of elements in path
+	 */
+	public isLeaf(elements: number) {
+		return this.query === "" && this.pathParts.length === elements;
+	}
 
-    /**
-     * Creates a sub request starting at a specific path part of this request's url
-     * The sub request url always has a leading slash, and always include query params if original url has any
-     * e.g. original url is /a/b/?queryParams, createSubRequest(0) is /a/b/?queryParams
-     * createSubRequest(1) is /b/?queryParams
-     * createSubRequest(2) is /?queryParams
-     * createSubRequest(n) where n is bigger than parts length, e.g. 2, or n is less than 0 will throw an exception
-     *
-     * note: query params are not counted towards path parts.
-     *
-     * @param startingPathIndex - The index of the first path part of the sub request
-     */
-    public createSubRequest(startingPathIndex: number): IRequest {
-        const pathLen = this.pathParts.length;
-        if (startingPathIndex < 0 || startingPathIndex > pathLen) {
-            throw new Error("incorrect sub-request");
-        }
-        if (startingPathIndex === pathLen && this.url.includes("?")) {
-            return {
-                url: `/${this.query}`,
-                headers: this.headers,
-            };
-        }
-        const path = `/${this.pathParts.slice(startingPathIndex).join("/")}`;
-        return {
-            url: this.query === "" ? path : `${path}/${this.query}`,
-            headers: this.headers,
-        };
-    }
+	/**
+	 * Creates a sub request starting at a specific path part of this request's url
+	 * The sub request url always has a leading slash, and always include query params if original url has any
+	 * e.g. original url is /a/b/?queryParams, createSubRequest(0) is /a/b/?queryParams
+	 * createSubRequest(1) is /b/?queryParams
+	 * createSubRequest(2) is /?queryParams
+	 * createSubRequest(n) where n is bigger than parts length, e.g. 2, or n is less than 0 will throw an exception
+	 *
+	 * note: query params are not counted towards path parts.
+	 *
+	 * @param startingPathIndex - The index of the first path part of the sub request
+	 */
+	public createSubRequest(startingPathIndex: number): IRequest {
+		const pathLen = this.pathParts.length;
+		if (startingPathIndex < 0 || startingPathIndex > pathLen) {
+			throw new Error("incorrect sub-request");
+		}
+		if (startingPathIndex === pathLen && this.url.includes("?")) {
+			return {
+				url: `/${this.query}`,
+				headers: this.headers,
+			};
+		}
+		const path = `/${this.pathParts.slice(startingPathIndex).join("/")}`;
+		return {
+			url: this.query === "" ? path : `${path}/${this.query}`,
+			headers: this.headers,
+		};
+	}
 }

package/src/runtimeFactoryHelper.ts

@@ -4,27 +4,34 @@
  */
 
 import {
-    IContainerContext,
-    IRuntime,
-    IRuntimeFactory,
+	IContainerContext,
+	IRuntime,
+	IRuntimeFactory,
 } from "@fluidframework/container-definitions";
 import { IContainerRuntime } from "@fluidframework/container-runtime-definitions";
 
 export abstract class RuntimeFactoryHelper<T = IContainerRuntime> implements IRuntimeFactory {
-    public get IRuntimeFactory() { return this; }
+	public get IRuntimeFactory() {
+		return this;
+	}
 
-    public async instantiateRuntime(
-        context: IContainerContext,
-        existing: boolean,
-    ): Promise<IRuntime> {
-        const runtime = await this.preInitialize(context, existing);
-        await (existing ? this.instantiateFromExisting(runtime) : this.instantiateFirstTime(runtime));
-        await this.hasInitialized(runtime);
-        return runtime;
-    }
+	public async instantiateRuntime(
+		context: IContainerContext,
+		existing: boolean,
+	): Promise<IRuntime> {
+		const runtime = await this.preInitialize(context, existing);
+		await (existing
+			? this.instantiateFromExisting(runtime)
+			: this.instantiateFirstTime(runtime));
+		await this.hasInitialized(runtime);
+		return runtime;
+	}
 
-    public abstract preInitialize(context: IContainerContext, existing: boolean): Promise<IRuntime & T>;
-    public async instantiateFirstTime(_runtime: T): Promise<void> {}
-    public async instantiateFromExisting(_runtime: T): Promise<void> {}
-    public async hasInitialized(_runtime: T): Promise<void> {}
+	public abstract preInitialize(
+		context: IContainerContext,
+		existing: boolean,
+	): Promise<IRuntime & T>;
+	public async instantiateFirstTime(_runtime: T): Promise<void> {}
+	public async instantiateFromExisting(_runtime: T): Promise<void> {}
+	public async hasInitialized(_runtime: T): Promise<void> {}
 }