@fluidframework/driver-web-cache 0.58.2000-58133

package/lib/scheduleIdleTask.js

@@ -0,0 +1,76 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+// A set of tasks that still have to be run
+let taskQueue = [];
+// Set to true when we have a pending idle task scheduled
+let idleTaskScheduled = false;
+/**
+ * A function that schedules a non critical task to be run when the browser has cycles available
+ * @param task - The task to be executed
+ * @param options - Optional configuration for the task execution
+ */
+export function scheduleIdleTask(task) {
+    taskQueue.push({
+        task,
+    });
+    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;
+    }
+}
+/**
+ * Runs tasks from the task queue
+ * @param filter - An optional function that will be called for each task to see if it should run.
+ * Returns false for tasks that should not run. If omitted all tasks run.
+ * @param shouldContinueRunning - An optional function that will be called to determine if
+ * we have enough time to continue running tasks. If omitted, we don't stop running tasks.
+ */
+function runTasks(filter, shouldContinueRunning) {
+    // The next value for the task queue
+    const newTaskQueue = [];
+    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];
+        if (filter && !filter(taskQueueItem)) {
+            newTaskQueue.push(taskQueueItem);
+        }
+        else {
+            taskQueueItem.task();
+        }
+    }
+    taskQueue = newTaskQueue;
+}
+// Runs all the tasks in the task queue
+function idleTaskCallback(deadline) {
+    // 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();
+    }
+}
+//# sourceMappingURL=scheduleIdleTask.js.map

package/lib/scheduleIdleTask.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scheduleIdleTask.js","sourceRoot":"","sources":["../src/scheduleIdleTask.ts"],"names":[],"mappings":"AAAA;;;GAGG;AA0BH,2CAA2C;AAC3C,IAAI,SAAS,GAAoB,EAAE,CAAC;AAEpC,yDAAyD;AACzD,IAAI,iBAAiB,GAAG,KAAK,CAAC;AAE9B;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAAgB;IAC7C,SAAS,CAAC,IAAI,CAAC;QACX,IAAI;KACP,CAAC,CAAC;IAEH,kBAAkB,EAAE,CAAC;AACzB,CAAC;AAED;;GAEG;AACH,SAAS,kBAAkB;IACvB,IAAI,CAAC,iBAAiB,EAAE;QACpB,gGAAgG;QAChG,IAAI,MAAM,CAAC,mBAAmB,EAAE;YAC5B,MAAM,CAAC,mBAAmB,CAAC,gBAAgB,CAAC,CAAC;SAChD;aAAM;YACH,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,EAAE,CAAC;YACjC,MAAM,CAAC,UAAU,CACb,GAAG,EAAE,CACD,gBAAgB,CAAC;gBACb,aAAa,EAAE,GAAG,EAAE,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,EAAE,CAAC,CAAC;gBACvD,UAAU,EAAE,KAAK;aACpB,CAAC,EACN,CAAC,CACJ,CAAC;SACL;QACD,iBAAiB,GAAG,IAAI,CAAC;KAC5B;AACL,CAAC;AAED;;;;;;GAMG;AACH,SAAS,QAAQ,CACb,MAAkD,EAClD,qBAAqC;IAErC,oCAAoC;IACpC,MAAM,YAAY,GAAoB,EAAE,CAAC;IAEzC,KAAK,IAAI,KAAK,GAAG,CAAC,EAAE,KAAK,GAAG,SAAS,CAAC,MAAM,EAAE,KAAK,IAAI,CAAC,EAAE;QACtD,IAAI,qBAAqB,IAAI,CAAC,qBAAqB,EAAE,EAAE;YACnD,kEAAkE;YAClE,YAAY,CAAC,IAAI,CAAC,GAAG,SAAS,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,CAAC;YAC7C,MAAM;SACT;QAED,MAAM,aAAa,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;QAEvC,IAAI,MAAM,IAAI,CAAC,MAAM,CAAC,aAAa,CAAC,EAAE;YAClC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC;SACpC;aAAM;YACH,aAAa,CAAC,IAAI,EAAE,CAAC;SACxB;KACJ;IAED,SAAS,GAAG,YAAY,CAAC;AAC7B,CAAC;AAED,uCAAuC;AACvC,SAAS,gBAAgB,CAAC,QAGzB;IACG,wEAAwE;IACxE,MAAM,WAAW,GAAG,EAAE,CAAC;IACvB,QAAQ,CAAC,SAAS,EAAE,GAAG,EAAE,CAAC,QAAQ,CAAC,aAAa,EAAE,GAAG,WAAW,CAAC,CAAC;IAClE,iBAAiB,GAAG,KAAK,CAAC;IAE1B,4EAA4E;IAC5E,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE;QACtB,kBAAkB,EAAE,CAAC;KACxB;AACL,CAAC","sourcesContent":["/*!\n * Copyright (c) Microsoft Corporation and contributors. All rights reserved.\n * Licensed under the MIT License.\n */\n\n// Older versions of Typescript considered this API experimental and not in Typescript included types.\n// This can be removed when FF updates to Typescript 4.4 or later\ndeclare global {\n    interface Window {\n        requestIdleCallback:\n        | ((\n            callback: (deadline: {\n                readonly didTimeout: boolean;\n                timeRemaining: () => number;\n            }) => void,\n            opts?: {\n                timeout: number;\n            }\n        ) => number)\n        | undefined;\n        cancelIdleCallback: ((handle: number) => void) | undefined;\n    }\n}\n\ninterface TaskQueueItem {\n    /** The task to run */\n    task: () => void;\n}\n\n// A set of tasks that still have to be run\nlet taskQueue: TaskQueueItem[] = [];\n\n// Set to true when we have a pending idle task scheduled\nlet idleTaskScheduled = false;\n\n/**\n * A function that schedules a non critical task to be run when the browser has cycles available\n * @param task - The task to be executed\n * @param options - Optional configuration for the task execution\n */\nexport function scheduleIdleTask(task: () => void) {\n    taskQueue.push({\n        task,\n    });\n\n    ensureIdleCallback();\n}\n\n/**\n * Ensures an idle callback has been scheduled for the remaining tasks\n */\nfunction ensureIdleCallback() {\n    if (!idleTaskScheduled) {\n        // Exception added when eslint rule was added, this should be revisited when modifying this code\n        if (window.requestIdleCallback) {\n            window.requestIdleCallback(idleTaskCallback);\n        } else {\n            const deadline = Date.now() + 50;\n            window.setTimeout(\n                () =>\n                    idleTaskCallback({\n                        timeRemaining: () => Math.max(deadline - Date.now(), 0),\n                        didTimeout: false,\n                    }),\n                0,\n            );\n        }\n        idleTaskScheduled = true;\n    }\n}\n\n/**\n * Runs tasks from the task queue\n * @param filter - An optional function that will be called for each task to see if it should run.\n * Returns false for tasks that should not run. If omitted all tasks run.\n * @param shouldContinueRunning - An optional function that will be called to determine if\n * we have enough time to continue running tasks. If omitted, we don't stop running tasks.\n */\nfunction runTasks(\n    filter?: (taskQueueItem: TaskQueueItem) => boolean,\n    shouldContinueRunning?: () => boolean,\n) {\n    // The next value for the task queue\n    const newTaskQueue: TaskQueueItem[] = [];\n\n    for (let index = 0; index < taskQueue.length; index += 1) {\n        if (shouldContinueRunning && !shouldContinueRunning()) {\n            // Add the tasks we didn't get to to the end of the new task queue\n            newTaskQueue.push(...taskQueue.slice(index));\n            break;\n        }\n\n        const taskQueueItem = taskQueue[index];\n\n        if (filter && !filter(taskQueueItem)) {\n            newTaskQueue.push(taskQueueItem);\n        } else {\n            taskQueueItem.task();\n        }\n    }\n\n    taskQueue = newTaskQueue;\n}\n\n// Runs all the tasks in the task queue\nfunction idleTaskCallback(deadline: {\n    timeRemaining: () => number;\n    readonly didTimeout: boolean;\n}) {\n    // Minimum time that must be available on deadline to run any more tasks\n    const minTaskTime = 10;\n    runTasks(undefined, () => deadline.timeRemaining() > minTaskTime);\n    idleTaskScheduled = false;\n\n    // If we didn't run through the entire queue, schedule another idle callback\n    if (taskQueue.length > 0) {\n        ensureIdleCallback();\n    }\n}\n"]}

package/package.json

@@ -0,0 +1,67 @@
+{
+  "name": "@fluidframework/driver-web-cache",
+  "version": "0.58.2000-58133",
+  "description": "Implementation of the driver caching API for a web browser",
+  "homepage": "https://fluidframework.com",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/microsoft/FluidFramework.git",
+    "directory": "packages/drivers/driver-web-cache"
+  },
+  "license": "MIT",
+  "author": "Microsoft and contributors",
+  "sideEffects": false,
+  "main": "dist/index.js",
+  "module": "lib/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "npm run build:genver && concurrently npm:build:compile npm:lint && npm run build:docs",
+    "build:commonjs": "npm run tsc && npm run build:test",
+    "build:compile": "concurrently npm:build:commonjs npm:build:esnext",
+    "build:docs": "api-extractor run --local --typescript-compiler-folder ../../../node_modules/typescript && copyfiles -u 1 ./_api-extractor-temp/doc-models/* ../../../_api-extractor-temp/",
+    "build:esnext": "tsc --project ./tsconfig.esnext.json",
+    "build:full": "npm run build",
+    "build:full:compile": "npm run build:compile",
+    "build:genver": "gen-version",
+    "build:test": "tsc --project ./src/test/tsconfig.json",
+    "ci:build:docs": "api-extractor run --typescript-compiler-folder ../../../node_modules/typescript && copyfiles -u 1 ./_api-extractor-temp/* ../../../_api-extractor-temp/",
+    "clean": "rimraf dist lib *.tsbuildinfo *.build.log",
+    "eslint": "eslint --format stylish src",
+    "eslint:fix": "eslint --format stylish src --fix --fix-type problem,suggestion,layout",
+    "lint": "npm run eslint",
+    "lint:fix": "npm run eslint:fix",
+    "test": "jest",
+    "tsc": "tsc",
+    "tsfmt": "tsfmt --verify",
+    "tsfmt:fix": "tsfmt --replace"
+  },
+  "dependencies": {
+    "@fluidframework/common-definitions": "^0.20.1",
+    "@fluidframework/odsp-driver-definitions": "0.58.2000-58133",
+    "@fluidframework/telemetry-utils": "0.58.2000-58133",
+    "idb": "^6.1.2"
+  },
+  "devDependencies": {
+    "@fluidframework/build-common": "^0.23.0",
+    "@fluidframework/eslint-config-fluid": "^0.27.0",
+    "@microsoft/api-extractor": "^7.16.1",
+    "@rushstack/eslint-config": "^2.5.1",
+    "@types/jest": "22.2.3",
+    "@types/node": "^14.18.0",
+    "@typescript-eslint/eslint-plugin": "~5.9.0",
+    "@typescript-eslint/parser": "~5.9.0",
+    "concurrently": "^6.2.0",
+    "copyfiles": "^2.1.0",
+    "eslint": "~8.6.0",
+    "eslint-plugin-editorconfig": "~3.2.0",
+    "eslint-plugin-eslint-comments": "~3.2.0",
+    "eslint-plugin-import": "~2.25.4",
+    "eslint-plugin-no-null": "~1.0.2",
+    "eslint-plugin-react": "~7.28.0",
+    "eslint-plugin-unicorn": "~40.0.0",
+    "fake-indexeddb": "3.1.4",
+    "jest": "^26.6.3",
+    "typescript": "~4.1.3",
+    "typescript-formatter": "7.1.0"
+  }
+}

package/src/FluidCache.ts

@@ -0,0 +1,276 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import {
+    IPersistedCache,
+    ICacheEntry,
+    IFileEntry,
+} from "@fluidframework/odsp-driver-definitions";
+import {
+    ITelemetryBaseLogger,
+    ITelemetryLogger,
+} from "@fluidframework/common-definitions";
+import { ChildLogger } from "@fluidframework/telemetry-utils";
+import { scheduleIdleTask } from "./scheduleIdleTask";
+import {
+    getFluidCacheIndexedDbInstance,
+    FluidDriverObjectStoreName,
+    getKeyForCacheEntry,
+} from "./FluidCacheIndexedDb";
+import {
+    FluidCacheErrorEvent,
+    FluidCacheEventSubCategories,
+    FluidCacheGenericEvent,
+} from "./fluidCacheTelemetry";
+
+// Some browsers have a usageDetails property that will tell you more detailed information
+// on how the storage is being used
+interface StorageQuotaUsageDetails {
+    indexedDB: number | undefined;
+}
+
+export interface FluidCacheConfig {
+    /**
+     * 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, and has been chosen
+     * vs undefined so that it is clear this is an intentional choice by the caller.
+     * A null value should only be used when the host can ensure that the cache is not able
+     * to be shared with multiple users.
+     */
+    // eslint-disable-next-line @rushstack/no-new-null
+    partitionKey: string | null;
+
+    /**
+     * A logger that can be used to get insight into cache performance and errors
+     */
+    logger?: ITelemetryBaseLogger;
+
+    /**
+     * A value in milliseconds that determines the maximum age of a cache entry to return.
+     * If an entry exists in the cache, but is older than this value, the cached value will not be returned.
+     */
+    maxCacheItemAge: number;
+}
+
+/**
+ * A cache that can be used by the Fluid ODSP driver to cache data for faster performance
+ */
+export class FluidCache implements IPersistedCache {
+    private readonly logger: ITelemetryLogger;
+
+    private readonly partitionKey: string | null;
+
+    private readonly maxCacheItemAge: number;
+
+    constructor(config: FluidCacheConfig) {
+        this.logger = ChildLogger.create(config.logger);
+        this.partitionKey = config.partitionKey;
+        this.maxCacheItemAge = config.maxCacheItemAge;
+
+        scheduleIdleTask(async () => {
+            // Log how much storage space is currently being used by indexed db.
+            // NOTE: This API is not supported in all browsers and it doesn't let you see the size of a specific DB.
+            // Exception added when eslint rule was added, this should be revisited when modifying this code
+            if (navigator.storage && navigator.storage.estimate) {
+                const estimate = await navigator.storage.estimate();
+
+                // Some browsers have a usageDetails property that will tell you
+                // more detailed information on how the storage is being used
+                let indexedDBSize: number | undefined;
+                if ("usageDetails" in estimate) {
+                    indexedDBSize = (
+                        (estimate as any)
+                            .usageDetails as StorageQuotaUsageDetails
+                    ).indexedDB;
+                }
+
+                this.logger.sendTelemetryEvent({
+                    eventName: FluidCacheGenericEvent.FluidCacheStorageInfo,
+                    subCategory: FluidCacheEventSubCategories.FluidCache,
+                    quota: estimate.quota,
+                    usage: estimate.usage,
+                    indexedDBSize,
+                });
+            }
+        });
+
+        scheduleIdleTask(async () => {
+            // Delete entries that have not been accessed recently to clean up space
+            try {
+                const db = await getFluidCacheIndexedDbInstance(this.logger);
+
+                const transaction = db.transaction(
+                    FluidDriverObjectStoreName,
+                    "readwrite",
+                );
+                const index = transaction.store.index("lastAccessTimeMs");
+                // Get items that have not been accessed in 4 weeks
+                const keysToDelete = await index.getAllKeys(
+                    IDBKeyRange.upperBound(
+                        new Date().getTime() - 4 * 7 * 24 * 60 * 60 * 1000,
+                    ),
+                );
+
+                await Promise.all(
+                    keysToDelete.map((key) => transaction.store.delete(key)),
+                );
+                await transaction.done;
+            } catch (error: any) {
+                this.logger.sendErrorEvent(
+                    {
+                        eventName:
+                            FluidCacheErrorEvent.FluidCacheDeleteOldEntriesError,
+                    },
+                    error,
+                );
+            }
+        });
+    }
+
+    public async removeEntries(file: IFileEntry): Promise<void> {
+        try {
+            const db = await getFluidCacheIndexedDbInstance(this.logger);
+
+            const transaction = db.transaction(
+                FluidDriverObjectStoreName,
+                "readwrite",
+            );
+            const index = transaction.store.index("fileId");
+
+            const keysToDelete = await index.getAllKeys(file.docId);
+
+            await Promise.all(
+                keysToDelete.map((key) => transaction.store.delete(key)),
+            );
+            await transaction.done;
+        } catch (error: any) {
+            this.logger.sendErrorEvent(
+                {
+                    eventName:
+                        FluidCacheErrorEvent.FluidCacheDeleteOldEntriesError,
+                },
+                error,
+            );
+        }
+    }
+
+    public async get(cacheEntry: ICacheEntry): Promise<any> {
+        const startTime = performance.now();
+
+        const cachedItem = await this.getItemFromCache(cacheEntry);
+
+        this.logger.sendPerformanceEvent({
+            eventName: "FluidCacheAccess",
+            cacheHit: cachedItem !== undefined,
+            type: cacheEntry.type,
+            duration: performance.now() - startTime,
+        });
+
+        // Value will contain metadata like the expiry time, we just want to return the object we were asked to cache
+        // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+        return cachedItem?.cachedObject;
+    }
+
+    private async getItemFromCache(cacheEntry: ICacheEntry) {
+        try {
+            const key = getKeyForCacheEntry(cacheEntry);
+
+            const db = await getFluidCacheIndexedDbInstance(this.logger);
+
+            const value = await db.get(FluidDriverObjectStoreName, key);
+
+            if (!value) {
+                return undefined;
+            }
+
+            // If the data does not come from the same partition, don't return it
+            if (value.partitionKey !== this.partitionKey) {
+                this.logger.sendTelemetryEvent({
+                    eventName:
+                        FluidCacheGenericEvent.FluidCachePartitionKeyMismatch,
+                    subCategory: FluidCacheEventSubCategories.FluidCache,
+                });
+
+                return undefined;
+            }
+
+            const currentTime = new Date().getTime();
+
+            // If too much time has passed since this cache entry was used, we will also return undefined
+            if (currentTime - value.createdTimeMs > this.maxCacheItemAge) {
+                return undefined;
+            }
+
+            const transaction = db.transaction(
+                FluidDriverObjectStoreName,
+                "readwrite",
+            );
+            // We don't want to block the get return of this function on updating the last accessed time
+            // We catch this promise because there is no user bad if this is rejected.
+            transaction.store
+                .get(key)
+                .then(async (valueToUpdate) => {
+                    // This value in the database could have been updated concurrently by other tabs/iframes
+                    // since we first read it. Only update the last accessed time if the current value in the
+                    // DB was the same one we returned.
+                    if (
+                        valueToUpdate !== undefined &&
+                        valueToUpdate.createdTimeMs === value.createdTimeMs &&
+                        (valueToUpdate.lastAccessTimeMs === undefined ||
+                            valueToUpdate.lastAccessTimeMs < currentTime)
+                    ) {
+                        await transaction.store.put(
+                            { ...valueToUpdate, lastAccessTimeMs: currentTime },
+                            key,
+                        );
+                    }
+                    await transaction.done;
+
+                    db.close();
+                })
+                .catch(() => { });
+            return value;
+        } catch (error: any) {
+            // We can fail to open the db for a variety of reasons,
+            // such as the database version having upgraded underneath us. Return undefined in this case
+            this.logger.sendErrorEvent(
+                { eventName: FluidCacheErrorEvent.FluidCacheGetError },
+                error,
+            );
+            return undefined;
+        }
+    }
+
+    public async put(entry: ICacheEntry, value: any): Promise<void> {
+        try {
+            const db = await getFluidCacheIndexedDbInstance(this.logger);
+
+            const currentTime = new Date().getTime();
+
+            await db.put(
+                FluidDriverObjectStoreName,
+                {
+                    cachedObject: value,
+                    fileId: entry.file.docId,
+                    type: entry.type,
+                    cacheItemId: entry.key,
+                    partitionKey: this.partitionKey,
+                    createdTimeMs: currentTime,
+                    lastAccessTimeMs: currentTime,
+                },
+                getKeyForCacheEntry(entry),
+            );
+
+            db.close();
+        } catch (error: any) {
+            // We can fail to open the db for a variety of reasons,
+            // such as the database version having upgraded underneath us
+            this.logger.sendErrorEvent(
+                { eventName: FluidCacheErrorEvent.FluidCachePutError },
+                error,
+            );
+        }
+    }
+}

package/src/FluidCacheIndexedDb.ts

@@ -0,0 +1,155 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+import { openDB, DBSchema, IDBPDatabase, deleteDB } from "idb";
+import { ICacheEntry } from "@fluidframework/odsp-driver-definitions";
+import { ITelemetryBaseLogger } from "@fluidframework/common-definitions";
+import { ChildLogger } from "@fluidframework/telemetry-utils";
+import { FluidCacheErrorEvent } from "./fluidCacheTelemetry";
+
+// The name of the database that we use for caching Fluid info.
+export const FluidDriverCacheDBName = "fluidDriverCache";
+
+// The name of the object store within the indexed db instance that the driver will use to cache Fluid content.
+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 function getKeyForCacheEntry(entry: ICacheEntry) {
+    return `${entry.file.docId}_${entry.type}_${entry.key}`;
+}
+
+export function getFluidCacheIndexedDbInstance(
+    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);
+    });
+}
+
+// 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);
+}
+
+/**
+ * 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;
+        };
+    };
+}

package/src/fluidCacheTelemetry.ts

@@ -0,0 +1,21 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export const enum FluidCacheGenericEvent {
+    "FluidCacheStorageInfo" = "FluidCacheStorageInfo",
+    "FluidCachePartitionKeyMismatch" = "FluidCachePartitionKeyMismatch",
+}
+
+export const enum FluidCacheErrorEvent {
+    "FluidCacheDeleteOldEntriesError" = "FluidCacheDeleteOldEntriesError",
+    "FluidCacheGetError" = "FluidCacheGetError",
+    "FluidCachePutError" = "FluidCachePutError",
+    "FluidCacheUpdateUsageError" = "FluidCacheUpdateUsageError",
+    "FluidCacheDeleteOldDbError" = "FluidCacheDeleteOldDbError",
+}
+
+export const enum FluidCacheEventSubCategories {
+    "FluidCache" = "FluidCache",
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+
+export * from "./FluidCache";
+export { deleteFluidCacheIndexDbInstance } from "./FluidCacheIndexedDb";

package/src/packageVersion.ts

@@ -0,0 +1,9 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ *
+ * THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY
+ */
+
+export const pkgName = "@fluidframework/driver-web-cache";
+export const pkgVersion = "0.58.2000-58133";