@fluidframework/driver-web-cache 2.0.0-internal.3.0.2 → 2.0.0-internal.3.2.0

package/src/FluidCacheIndexedDb.ts

@@ -18,138 +18,122 @@ export const FluidDriverObjectStoreName = "driverStorage.V3";
 export const CurrentCacheVersion = 3;
 
 // Note that V1 and V2 were misspelled as "diver", and we need to keep using the misspelling here.
-export const oldVersionNameMapping: Partial<{ [key: number]: string; }> = {
-    1: "diverStorage",
-    2: "diverStorage.V2",
+export const oldVersionNameMapping: Partial<{ [key: number]: string }> = {
+	1: "diverStorage",
+	2: "diverStorage.V2",
 };
 
 export function getKeyForCacheEntry(entry: ICacheEntry) {
-    return `${entry.file.docId}_${entry.type}_${entry.key}`;
+	return `${entry.file.docId}_${entry.type}_${entry.key}`;
 }
 
 export function getFluidCacheIndexedDbInstance(
-    logger?: ITelemetryBaseLogger,
+	logger?: ITelemetryBaseLogger,
 ): Promise<IDBPDatabase<FluidCacheDBSchema>> {
-    return new Promise((resolve, reject) => {
-        openDB<FluidCacheDBSchema>(
-            FluidDriverCacheDBName,
-            CurrentCacheVersion,
-            {
-                upgrade: (db, oldVersion) => {
-                    try {
-                        // We changed the format of the object store, so we must
-                        // delete the old stores to create a new one in V3
-                        const cacheToDelete = oldVersionNameMapping[oldVersion];
-                        if (cacheToDelete) {
-                            // We don't include the old object stores in the schema, so we need to
-                            // use a typecast here to prevent IDB from complaining
-                            db.deleteObjectStore(cacheToDelete as any);
-                        }
-                    } catch (error: any) {
-                        // Catch any error done when attempting to delete the older version.
-                        // If the object does not exist db will throw.
-                        // We can now assume that the old version is no longer there regardless.
-                        ChildLogger.create(logger).sendErrorEvent(
-                            {
-                                eventName:
-                                    FluidCacheErrorEvent.FluidCacheDeleteOldDbError,
-                            },
-                            error,
-                        );
-                    }
-
-                    const cacheObjectStore = db.createObjectStore(
-                        FluidDriverObjectStoreName,
-                    );
-                    cacheObjectStore.createIndex(
-                        "createdTimeMs",
-                        "createdTimeMs",
-                    );
-                    cacheObjectStore.createIndex(
-                        "lastAccessTimeMs",
-                        "lastAccessTimeMs",
-                    );
-                    cacheObjectStore.createIndex(
-                        "partitionKey",
-                        "partitionKey",
-                    );
-                    cacheObjectStore.createIndex("fileId", "fileId");
-                },
-                blocked: () => {
-                    reject(
-                        new Error(
-                            "Could not open DB since it is blocked by an older client that has the DB open",
-                        ),
-                    );
-                },
-            },
-        ).then(resolve, reject);
-    });
+	return new Promise((resolve, reject) => {
+		openDB<FluidCacheDBSchema>(FluidDriverCacheDBName, CurrentCacheVersion, {
+			upgrade: (db, oldVersion) => {
+				try {
+					// We changed the format of the object store, so we must
+					// delete the old stores to create a new one in V3
+					const cacheToDelete = oldVersionNameMapping[oldVersion];
+					if (cacheToDelete) {
+						// We don't include the old object stores in the schema, so we need to
+						// use a typecast here to prevent IDB from complaining
+						db.deleteObjectStore(cacheToDelete as any);
+					}
+				} catch (error: any) {
+					// Catch any error done when attempting to delete the older version.
+					// If the object does not exist db will throw.
+					// We can now assume that the old version is no longer there regardless.
+					ChildLogger.create(logger).sendErrorEvent(
+						{
+							eventName: FluidCacheErrorEvent.FluidCacheDeleteOldDbError,
+						},
+						error,
+					);
+				}
+
+				const cacheObjectStore = db.createObjectStore(FluidDriverObjectStoreName);
+				cacheObjectStore.createIndex("createdTimeMs", "createdTimeMs");
+				cacheObjectStore.createIndex("lastAccessTimeMs", "lastAccessTimeMs");
+				cacheObjectStore.createIndex("partitionKey", "partitionKey");
+				cacheObjectStore.createIndex("fileId", "fileId");
+			},
+			blocked: () => {
+				reject(
+					new Error(
+						"Could not open DB since it is blocked by an older client that has the DB open",
+					),
+				);
+			},
+		}).then(resolve, reject);
+	});
 }
 
 // Deletes the indexed DB instance.
 // Warning this can throw an error in Firefox incognito, where accessing storage is prohibited.
 export function deleteFluidCacheIndexDbInstance(): Promise<void> {
-    return deleteDB(FluidDriverCacheDBName);
+	return deleteDB(FluidDriverCacheDBName);
 }
 
 /**
  * Schema for the object store used to cache driver information
  */
 export interface FluidCacheDBSchema extends DBSchema {
-    [FluidDriverObjectStoreName]: {
-        /**
-         * A unique identifier for an item in the cache. It is a combination of file, type, and cacheItemId
-         */
-        key: string;
-
-        value: {
-            /**
-             * The identifier of the file associated with the cache entry
-             */
-            fileId: string;
-
-            /**
-             * Describes the type of content being cached, such as snapshot
-             */
-            type: string;
-
-            /**
-             * Files may have multiple cached items associated with them,
-             * this property uniquely identifies a specific cache entry for a file.
-             * This is not globally unique, but rather a unique id for this file
-             */
-            cacheItemId: string;
-
-            /*
-             * Opaque object that the driver asks us to store in a cache for performance reasons
-             */
-            cachedObject: any;
-
-            /**
-             * A string to specify what partition of the cache you wish to use (e.g. a user id).
-             * Null can be used to explicity indicate no partitioning.
-             */
-            // eslint-disable-next-line @rushstack/no-new-null
-            partitionKey: string | null;
-
-            /**
-             * The time when the cache entry was put into the cache
-             */
-            createdTimeMs: number;
-
-            /**
-             * The last time the cache entry was used.
-             * This is initially set to the time the cache entry was created Measured as ms since unix epoch.
-             */
-            lastAccessTimeMs: number;
-        };
-
-        indexes: {
-            createdTimeMs: number;
-            partitionKey: string;
-            lastAccessTimeMs: number;
-            fileId: string;
-        };
-    };
+	[FluidDriverObjectStoreName]: {
+		/**
+		 * A unique identifier for an item in the cache. It is a combination of file, type, and cacheItemId
+		 */
+		key: string;
+
+		value: {
+			/**
+			 * The identifier of the file associated with the cache entry
+			 */
+			fileId: string;
+
+			/**
+			 * Describes the type of content being cached, such as snapshot
+			 */
+			type: string;
+
+			/**
+			 * Files may have multiple cached items associated with them,
+			 * this property uniquely identifies a specific cache entry for a file.
+			 * This is not globally unique, but rather a unique id for this file
+			 */
+			cacheItemId: string;
+
+			/*
+			 * Opaque object that the driver asks us to store in a cache for performance reasons
+			 */
+			cachedObject: any;
+
+			/**
+			 * A string to specify what partition of the cache you wish to use (e.g. a user id).
+			 * Null can be used to explicity indicate no partitioning.
+			 */
+			// eslint-disable-next-line @rushstack/no-new-null
+			partitionKey: string | null;
+
+			/**
+			 * The time when the cache entry was put into the cache
+			 */
+			createdTimeMs: number;
+
+			/**
+			 * The last time the cache entry was used.
+			 * This is initially set to the time the cache entry was created Measured as ms since unix epoch.
+			 */
+			lastAccessTimeMs: number;
+		};
+
+		indexes: {
+			createdTimeMs: number;
+			partitionKey: string;
+			lastAccessTimeMs: number;
+			fileId: string;
+		};
+	};
 }

package/src/fluidCacheTelemetry.ts

@@ -4,18 +4,18 @@
  */
 
 export const enum FluidCacheGenericEvent {
-    "FluidCacheStorageInfo" = "FluidCacheStorageInfo",
-    "FluidCachePartitionKeyMismatch" = "FluidCachePartitionKeyMismatch",
+	"FluidCacheStorageInfo" = "FluidCacheStorageInfo",
+	"FluidCachePartitionKeyMismatch" = "FluidCachePartitionKeyMismatch",
 }
 
 export const enum FluidCacheErrorEvent {
-    "FluidCacheDeleteOldEntriesError" = "FluidCacheDeleteOldEntriesError",
-    "FluidCacheGetError" = "FluidCacheGetError",
-    "FluidCachePutError" = "FluidCachePutError",
-    "FluidCacheUpdateUsageError" = "FluidCacheUpdateUsageError",
-    "FluidCacheDeleteOldDbError" = "FluidCacheDeleteOldDbError",
+	"FluidCacheDeleteOldEntriesError" = "FluidCacheDeleteOldEntriesError",
+	"FluidCacheGetError" = "FluidCacheGetError",
+	"FluidCachePutError" = "FluidCachePutError",
+	"FluidCacheUpdateUsageError" = "FluidCacheUpdateUsageError",
+	"FluidCacheDeleteOldDbError" = "FluidCacheDeleteOldDbError",
 }
 
 export const enum FluidCacheEventSubCategories {
-    "FluidCache" = "FluidCache",
+	"FluidCache" = "FluidCache",
 }

package/src/packageVersion.ts

@@ -6,4 +6,4 @@
  */
 
 export const pkgName = "@fluidframework/driver-web-cache";
-export const pkgVersion = "2.0.0-internal.3.0.2";
+export const pkgVersion = "2.0.0-internal.3.2.0";

package/src/scheduleIdleTask.ts

@@ -4,8 +4,8 @@
  */
 
 interface TaskQueueItem {
-    /** The task to run */
-    task: () => void;
+	/** The task to run */
+	task: () => void;
 }
 
 // A set of tasks that still have to be run
@@ -20,34 +20,34 @@ let idleTaskScheduled = false;
  * @param options - Optional configuration for the task execution
  */
 export function scheduleIdleTask(task: () => void) {
-    taskQueue.push({
-        task,
-    });
+	taskQueue.push({
+		task,
+	});
 
-    ensureIdleCallback();
+	ensureIdleCallback();
 }
 
 /**
  * Ensures an idle callback has been scheduled for the remaining tasks
  */
 function ensureIdleCallback() {
-    if (!idleTaskScheduled) {
-        // Exception added when eslint rule was added, this should be revisited when modifying this code
-        if (window.requestIdleCallback) {
-            window.requestIdleCallback(idleTaskCallback);
-        } else {
-            const deadline = Date.now() + 50;
-            window.setTimeout(
-                () =>
-                    idleTaskCallback({
-                        timeRemaining: () => Math.max(deadline - Date.now(), 0),
-                        didTimeout: false,
-                    }),
-                0,
-            );
-        }
-        idleTaskScheduled = true;
-    }
+	if (!idleTaskScheduled) {
+		// Exception added when eslint rule was added, this should be revisited when modifying this code
+		if (window.requestIdleCallback) {
+			window.requestIdleCallback(idleTaskCallback);
+		} else {
+			const deadline = Date.now() + 50;
+			window.setTimeout(
+				() =>
+					idleTaskCallback({
+						timeRemaining: () => Math.max(deadline - Date.now(), 0),
+						didTimeout: false,
+					}),
+				0,
+			);
+		}
+		idleTaskScheduled = true;
+	}
 }
 
 /**
@@ -58,43 +58,40 @@ function ensureIdleCallback() {
  * we have enough time to continue running tasks. If omitted, we don't stop running tasks.
  */
 function runTasks(
-    filter?: (taskQueueItem: TaskQueueItem) => boolean,
-    shouldContinueRunning?: () => boolean,
+	filter?: (taskQueueItem: TaskQueueItem) => boolean,
+	shouldContinueRunning?: () => boolean,
 ) {
-    // The next value for the task queue
-    const newTaskQueue: TaskQueueItem[] = [];
+	// The next value for the task queue
+	const newTaskQueue: TaskQueueItem[] = [];
 
-    for (let index = 0; index < taskQueue.length; index += 1) {
-        if (shouldContinueRunning && !shouldContinueRunning()) {
-            // Add the tasks we didn't get to to the end of the new task queue
-            newTaskQueue.push(...taskQueue.slice(index));
-            break;
-        }
+	for (let index = 0; index < taskQueue.length; index += 1) {
+		if (shouldContinueRunning && !shouldContinueRunning()) {
+			// Add the tasks we didn't get to to the end of the new task queue
+			newTaskQueue.push(...taskQueue.slice(index));
+			break;
+		}
 
-        const taskQueueItem = taskQueue[index];
+		const taskQueueItem = taskQueue[index];
 
-        if (filter && !filter(taskQueueItem)) {
-            newTaskQueue.push(taskQueueItem);
-        } else {
-            taskQueueItem.task();
-        }
-    }
+		if (filter && !filter(taskQueueItem)) {
+			newTaskQueue.push(taskQueueItem);
+		} else {
+			taskQueueItem.task();
+		}
+	}
 
-    taskQueue = newTaskQueue;
+	taskQueue = newTaskQueue;
 }
 
 // Runs all the tasks in the task queue
-function idleTaskCallback(deadline: {
-    timeRemaining: () => number;
-    readonly didTimeout: boolean;
-}) {
-    // Minimum time that must be available on deadline to run any more tasks
-    const minTaskTime = 10;
-    runTasks(undefined, () => deadline.timeRemaining() > minTaskTime);
-    idleTaskScheduled = false;
+function idleTaskCallback(deadline: { timeRemaining: () => number; readonly didTimeout: boolean }) {
+	// Minimum time that must be available on deadline to run any more tasks
+	const minTaskTime = 10;
+	runTasks(undefined, () => deadline.timeRemaining() > minTaskTime);
+	idleTaskScheduled = false;
 
-    // If we didn't run through the entire queue, schedule another idle callback
-    if (taskQueue.length > 0) {
-        ensureIdleCallback();
-    }
+	// If we didn't run through the entire queue, schedule another idle callback
+	if (taskQueue.length > 0) {
+		ensureIdleCallback();
+	}
 }

package/tsconfig.esnext.json

@@ -1,7 +1,7 @@
 {
-    "extends": "./tsconfig.json",
-    "compilerOptions": {
-        "outDir": "./lib",
-        "module": "esnext"
-    },
-}
+	"extends": "./tsconfig.json",
+	"compilerOptions": {
+		"outDir": "./lib",
+		"module": "esnext",
+	},
+}

package/tsconfig.json

@@ -1,15 +1,11 @@
 {
-    "extends": "@fluidframework/build-common/ts-common-config.json",
-    "exclude": [
-        "src/test/**/*"
-    ],
-    "compilerOptions": {
-        "rootDir": "./src",
-        "outDir": "./dist",
-        "composite": true,
-        "skipLibCheck": true
-    },
-    "include": [
-        "src/**/*"
-    ]
-}
+	"extends": "@fluidframework/build-common/ts-common-config.json",
+	"exclude": ["src/test/**/*"],
+	"compilerOptions": {
+		"rootDir": "./src",
+		"outDir": "./dist",
+		"composite": true,
+		"skipLibCheck": true,
+	},
+	"include": ["src/**/*"],
+}