Update eslint config in packages/runtime/runtime-utils to extend "recommended" base config

packages/runtime/container-runtime/src/channelCollection.ts

@@ -403,7 +403,7 @@ export class ChannelCollection implements IFluidDataStoreChannel, IDisposable {
 			const attachMessage = contents as InboundAttachMessage;
 			// We need to process the GC Data for both local and remote attach messages
 			const foundGCData = processAttachMessageGCData(
-				attachMessage.snapshot,
+				attachMessage.snapshot ?? undefined,
 				(nodeId, toPath) => {
 					// nodeId is the relative path under the node being attached. Always starts with "/", but no trailing "/" after an id
 					const fromPath = `/${attachMessage.id}${nodeId === "/" ? "" : nodeId}`;

packages/runtime/runtime-utils/.eslintrc.cjs

@@ -4,10 +4,7 @@
  */
 
 module.exports = {
-	extends: [
-		require.resolve("@fluidframework/eslint-config-fluid/minimal-deprecated"),
-		"prettier",
-	],
+	extends: [require.resolve("@fluidframework/eslint-config-fluid/recommended"), "prettier"],
 	parserOptions: {
 		project: ["./tsconfig.json", "./src/test/tsconfig.json"],
 	},

packages/runtime/runtime-utils/api-report/runtime-utils.legacy.alpha.api.md

@@ -10,7 +10,7 @@ export function compareFluidHandles(a: IFluidHandle, b: IFluidHandle): boolean;
 // @alpha
 export function convertToSummaryTreeWithStats(snapshot: ITree, fullTree?: boolean): ISummaryTreeWithStats;
 
-// @alpha (undocumented)
+// @alpha
 export const create404Response: (request: IRequest) => IResponse;
 
 // @alpha

packages/runtime/runtime-utils/src/dataStoreHelpers.ts

@@ -17,45 +17,67 @@ interface IResponseException extends Error {
 	message: string;
 	code: number;
 	stack?: string;
-	underlyingResponseHeaders?: { [key: string]: any };
+	underlyingResponseHeaders?: { [key: string]: unknown };
 }
 
 /**
+ * Type guard for determining if an error is an IResponseException
  * @internal
  */
-export function exceptionToResponse(err: any): IResponse {
+function isResponseException(err: unknown): err is IResponseException {
+	return (
+		err !== null &&
+		typeof err === "object" &&
+		"errorFromRequestFluidObject" in err &&
+		(err as { errorFromRequestFluidObject: unknown }).errorFromRequestFluidObject === true
+	);
+}
+
+/**
+ * Converts an error object into an {@link @fluidframework/core-interfaces#IResponse}
+ * @internal
+ */
+export function exceptionToResponse(err: unknown): IResponse {
 	const status = 500;
-	if (err !== null && typeof err === "object" && err.errorFromRequestFluidObject === true) {
-		const responseErr: IResponseException = err;
+	if (isResponseException(err)) {
 		return {
 			mimeType: "text/plain",
-			status: responseErr.code,
-			value: responseErr.message,
+			status: err.code,
+			value: err.message,
 			get stack() {
-				return responseErr.stack;
+				return err.stack;
 			},
-			headers: responseErr.underlyingResponseHeaders,
+			headers: err.underlyingResponseHeaders,
 		};
 	}
 
-	// Capture error objects, not stack itself, as stack retrieval is very expensive operation, so we delay it
+	// Capture error objects, not stack itself, as stack retrieval is very expensive operation
 	const errWithStack = generateErrorWithStack();
 
 	return {
 		mimeType: "text/plain",
 		status,
 		value: `${err}`,
 		get stack() {
-			return (err?.stack as string | undefined) ?? errWithStack.stack;
+			// Use type assertion after checking if err is an object with stack
+			return (
+				(typeof err === "object" && err !== null && "stack" in err
+					? (err.stack as string | undefined)
+					: undefined) ?? errWithStack.stack
+			);
 		},
 	};
 }
 
 /**
+ * Converts an IResponse object back into an Error object that can be thrown
+ * @param response - The IResponse object to convert
+ * @param request - The original IRequest object
+ * @returns An Error object with additional properties from the response
  * @internal
  */
 export function responseToException(response: IResponse, request: IRequest): Error {
-	const message = response.value;
+	const message = response.value as string;
 	const errWithStack = generateErrorWithStack();
 	const responseErr: Error & IResponseException = {
 		errorFromRequestFluidObject: true,
@@ -72,20 +94,29 @@ export function responseToException(response: IResponse, request: IRequest): Err
 }
 
 /**
+ * Creates a 404 "not found" response for the given request
+ * @param request - The request that resulted in the 404 response
+ * @returns An IResponse object with 404 status code
  * @legacy
  * @alpha
  */
-export const create404Response = (request: IRequest) =>
+export const create404Response = (request: IRequest): IResponse =>
 	createResponseError(404, "not found", request);
 
 /**
+ * Creates an error response with the specified status code and message
+ * @param status - HTTP status code for the error (must not be 200)
+ * @param value - Error message or description
+ * @param request - The request that resulted in this error
+ * @param headers - Optional headers to include in the response
+ * @returns An IResponse object representing the error
  * @internal
  */
 export function createResponseError(
 	status: number,
 	value: string,
 	request: IRequest,
-	headers?: { [key: string]: any },
+	headers?: { [key: string]: unknown },
 ): IResponse {
 	assert(status !== 200, 0x19b /* "Cannot not create response error on 200 status" */);
 	// Omit query string which could contain personal data unfit for logging
@@ -111,6 +142,11 @@ export function createResponseError(
 export type Factory = IFluidDataStoreFactory & Partial<IProvideFluidDataStoreRegistry>;
 
 /**
+ * Creates a combined IFluidDataStoreFactory and IFluidDataStoreRegistry implementation
+ * from a factory type and implementation
+ * @param type - The unique identifier for this data store factory
+ * @param factory - The factory implementation or promise that resolves to one
+ * @returns A combined factory and registry implementation
  * @internal
  */
 export function createDataStoreFactory(
@@ -125,8 +161,13 @@ export function createDataStoreFactory(
 		get IFluidDataStoreRegistry() {
 			return this;
 		},
-		instantiateDataStore: async (context, existing) =>
-			(await factory).instantiateDataStore(context, existing),
-		get: async (name: string) => (await factory).IFluidDataStoreRegistry?.get(name),
+		instantiateDataStore: async (context, existing) => {
+			const resolvedFactory = await factory;
+			return resolvedFactory.instantiateDataStore(context, existing);
+		},
+		get: async (name: string) => {
+			const resolvedFactory = await factory;
+			return resolvedFactory.IFluidDataStoreRegistry?.get(name);
+		},
 	};
 }

packages/runtime/runtime-utils/src/handles.ts

@@ -23,8 +23,11 @@ export interface ISerializedHandle {
  * Is the input object a @see ISerializedHandle?
  * @internal
  */
-export const isSerializedHandle = (value: any): value is ISerializedHandle =>
-	value?.type === "__fluid_handle__";
+export const isSerializedHandle = (value: unknown): value is ISerializedHandle =>
+	typeof value === "object" &&
+	value !== null &&
+	"type" in value &&
+	value.type === "__fluid_handle__";
 
 /**
  * Setting to opt into compatibility with handles from before {@link fluidHandleSymbol} existed (Fluid Framework client 2.0.0-rc.3.0.0 and earlier).

packages/runtime/runtime-utils/src/objectstorageutils.ts

@@ -6,15 +6,18 @@
 import { ITree } from "@fluidframework/driver-definitions/internal";
 
 /**
+ * Normalizes a storage path by removing leading and trailing slashes and splitting into parts
+ * @param path - The storage path to normalize (e.g. "/foo/bar/")
+ * @returns Array of path segments (e.g. ["foo", "bar"])
  * @internal
  */
-export function getNormalizedObjectStoragePathParts(path: string) {
+export function getNormalizedObjectStoragePathParts(path: string): string[] {
 	let normalizePath = path;
 	if (normalizePath.startsWith("/")) {
-		normalizePath = normalizePath.substr(1);
+		normalizePath = normalizePath.slice(1);
 	}
 	if (normalizePath.endsWith("/")) {
-		normalizePath = normalizePath.substr(0, normalizePath.length - 1);
+		normalizePath = normalizePath.slice(0, -1);
 	}
 	if (normalizePath.length > 0) {
 		return normalizePath.split("/");
@@ -23,6 +26,11 @@ export function getNormalizedObjectStoragePathParts(path: string) {
 }
 
 /**
+ * Lists all blobs at the specified path in the given tree
+ * @param inputTree - The tree to search within
+ * @param path - The path to search at (e.g. "foo/bar")
+ * @returns Promise that resolves to an array of blob names at that path
+ * @throws Error if the path does not exist in the tree
  * @internal
  */
 export async function listBlobsAtTreePath(
@@ -42,7 +50,7 @@ export async function listBlobsAtTreePath(
 		// 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) {
+	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);

packages/runtime/runtime-utils/src/requestParser.ts

@@ -17,21 +17,25 @@ export class RequestParser implements IRequest {
 	 */
 	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;
-			}, []);
+		const pathParts: string[] = [];
+		const urlPath = url.slice(
+			0,
+			Math.max(0, queryStartIndex < 0 ? url.length : queryStartIndex),
+		);
+
+		for (const part of urlPath.split("/")) {
+			if (part !== undefined && part.length > 0) {
+				pathParts.push(decodeURIComponent(part));
+			}
+		}
+
+		return pathParts;
 	}
 
 	private requestPathParts: readonly string[] | undefined;
 	public readonly query: string;
 
-	public static create(request: Readonly<IRequest>) {
+	public static create(request: Readonly<IRequest>): RequestParser {
 		// Perf optimizations.
 		if (request instanceof RequestParser) {
 			return request;
@@ -41,7 +45,8 @@ export class RequestParser implements IRequest {
 
 	protected constructor(private readonly request: Readonly<IRequest>) {
 		const queryStartIndex = this.request.url.indexOf("?");
-		this.query = queryStartIndex >= 0 ? this.request.url.substring(queryStartIndex) : "";
+		this.query =
+			queryStartIndex >= 0 ? this.request.url.slice(Math.max(0, queryStartIndex)) : "";
 		if (request.headers !== undefined) {
 			this.headers = request.headers;
 		}
@@ -67,7 +72,7 @@ export class RequestParser implements IRequest {
 	 * 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) {
+	public isLeaf(elements: number): boolean {
 		return this.query === "" && this.pathParts.length === elements;
 	}
 

packages/runtime/runtime-utils/src/runtimeFactoryHelper.ts

@@ -15,7 +15,7 @@ import { IContainerRuntime } from "@fluidframework/container-runtime-definitions
  * @alpha
  */
 export abstract class RuntimeFactoryHelper<T = IContainerRuntime> implements IRuntimeFactory {
-	public get IRuntimeFactory() {
+	public get IRuntimeFactory(): this {
 		return this;
 	}