/*
|
* Copyright (c) Microsoft Corporation. All rights reserved.
|
* Licensed under the MIT License.
|
*/
|
|
import {
|
createBrowserAuthError,
|
BrowserAuthErrorCodes,
|
} from "../error/BrowserAuthError.js";
|
import {
|
DB_NAME,
|
DB_TABLE_NAME,
|
DB_VERSION,
|
} from "../utils/BrowserConstants.js";
|
import { IAsyncStorage } from "./IAsyncStorage.js";
|
|
interface IDBOpenDBRequestEvent extends Event {
|
target: IDBOpenDBRequest & EventTarget;
|
}
|
|
interface IDBOpenOnUpgradeNeededEvent extends IDBVersionChangeEvent {
|
target: IDBOpenDBRequest & EventTarget;
|
}
|
|
interface IDBRequestEvent extends Event {
|
target: IDBRequest & EventTarget;
|
}
|
|
/**
|
* Storage wrapper for IndexedDB storage in browsers: https://developer.mozilla.org/en-US/docs/Web/API/IndexedDB_API
|
*/
|
export class DatabaseStorage<T> implements IAsyncStorage<T> {
|
private db: IDBDatabase | undefined;
|
private dbName: string;
|
private tableName: string;
|
private version: number;
|
private dbOpen: boolean;
|
|
constructor() {
|
this.dbName = DB_NAME;
|
this.version = DB_VERSION;
|
this.tableName = DB_TABLE_NAME;
|
this.dbOpen = false;
|
}
|
|
/**
|
* Opens IndexedDB instance.
|
*/
|
async open(): Promise<void> {
|
return new Promise((resolve, reject) => {
|
const openDB = window.indexedDB.open(this.dbName, this.version);
|
openDB.addEventListener(
|
"upgradeneeded",
|
(e: IDBVersionChangeEvent) => {
|
const event = e as IDBOpenOnUpgradeNeededEvent;
|
event.target.result.createObjectStore(this.tableName);
|
}
|
);
|
openDB.addEventListener("success", (e: Event) => {
|
const event = e as IDBOpenDBRequestEvent;
|
this.db = event.target.result;
|
this.dbOpen = true;
|
resolve();
|
});
|
openDB.addEventListener("error", () =>
|
reject(
|
createBrowserAuthError(
|
BrowserAuthErrorCodes.databaseUnavailable
|
)
|
)
|
);
|
});
|
}
|
|
/**
|
* Closes the connection to IndexedDB database when all pending transactions
|
* complete.
|
*/
|
closeConnection(): void {
|
const db = this.db;
|
if (db && this.dbOpen) {
|
db.close();
|
this.dbOpen = false;
|
}
|
}
|
|
/**
|
* Opens database if it's not already open
|
*/
|
private async validateDbIsOpen(): Promise<void> {
|
if (!this.dbOpen) {
|
return this.open();
|
}
|
}
|
|
/**
|
* Retrieves item from IndexedDB instance.
|
* @param key
|
*/
|
async getItem(key: string): Promise<T | null> {
|
await this.validateDbIsOpen();
|
return new Promise<T>((resolve, reject) => {
|
// TODO: Add timeouts?
|
if (!this.db) {
|
return reject(
|
createBrowserAuthError(
|
BrowserAuthErrorCodes.databaseNotOpen
|
)
|
);
|
}
|
const transaction = this.db.transaction(
|
[this.tableName],
|
"readonly"
|
);
|
const objectStore = transaction.objectStore(this.tableName);
|
const dbGet = objectStore.get(key);
|
|
dbGet.addEventListener("success", (e: Event) => {
|
const event = e as IDBRequestEvent;
|
this.closeConnection();
|
resolve(event.target.result);
|
});
|
|
dbGet.addEventListener("error", (e: Event) => {
|
this.closeConnection();
|
reject(e);
|
});
|
});
|
}
|
|
/**
|
* Adds item to IndexedDB under given key
|
* @param key
|
* @param payload
|
*/
|
async setItem(key: string, payload: T): Promise<void> {
|
await this.validateDbIsOpen();
|
return new Promise<void>((resolve: Function, reject: Function) => {
|
// TODO: Add timeouts?
|
if (!this.db) {
|
return reject(
|
createBrowserAuthError(
|
BrowserAuthErrorCodes.databaseNotOpen
|
)
|
);
|
}
|
const transaction = this.db.transaction(
|
[this.tableName],
|
"readwrite"
|
);
|
|
const objectStore = transaction.objectStore(this.tableName);
|
|
const dbPut = objectStore.put(payload, key);
|
|
dbPut.addEventListener("success", () => {
|
this.closeConnection();
|
resolve();
|
});
|
|
dbPut.addEventListener("error", (e) => {
|
this.closeConnection();
|
reject(e);
|
});
|
});
|
}
|
|
/**
|
* Removes item from IndexedDB under given key
|
* @param key
|
*/
|
async removeItem(key: string): Promise<void> {
|
await this.validateDbIsOpen();
|
return new Promise<void>((resolve: Function, reject: Function) => {
|
if (!this.db) {
|
return reject(
|
createBrowserAuthError(
|
BrowserAuthErrorCodes.databaseNotOpen
|
)
|
);
|
}
|
|
const transaction = this.db.transaction(
|
[this.tableName],
|
"readwrite"
|
);
|
const objectStore = transaction.objectStore(this.tableName);
|
const dbDelete = objectStore.delete(key);
|
|
dbDelete.addEventListener("success", () => {
|
this.closeConnection();
|
resolve();
|
});
|
|
dbDelete.addEventListener("error", (e) => {
|
this.closeConnection();
|
reject(e);
|
});
|
});
|
}
|
|
/**
|
* Get all the keys from the storage object as an iterable array of strings.
|
*/
|
async getKeys(): Promise<string[]> {
|
await this.validateDbIsOpen();
|
return new Promise<string[]>((resolve: Function, reject: Function) => {
|
if (!this.db) {
|
return reject(
|
createBrowserAuthError(
|
BrowserAuthErrorCodes.databaseNotOpen
|
)
|
);
|
}
|
|
const transaction = this.db.transaction(
|
[this.tableName],
|
"readonly"
|
);
|
const objectStore = transaction.objectStore(this.tableName);
|
const dbGetKeys = objectStore.getAllKeys();
|
|
dbGetKeys.addEventListener("success", (e: Event) => {
|
const event = e as IDBRequestEvent;
|
this.closeConnection();
|
resolve(event.target.result);
|
});
|
|
dbGetKeys.addEventListener("error", (e: Event) => {
|
this.closeConnection();
|
reject(e);
|
});
|
});
|
}
|
|
/**
|
*
|
* Checks whether there is an object under the search key in the object store
|
*/
|
async containsKey(key: string): Promise<boolean> {
|
await this.validateDbIsOpen();
|
|
return new Promise<boolean>((resolve: Function, reject: Function) => {
|
if (!this.db) {
|
return reject(
|
createBrowserAuthError(
|
BrowserAuthErrorCodes.databaseNotOpen
|
)
|
);
|
}
|
|
const transaction = this.db.transaction(
|
[this.tableName],
|
"readonly"
|
);
|
const objectStore = transaction.objectStore(this.tableName);
|
const dbContainsKey = objectStore.count(key);
|
|
dbContainsKey.addEventListener("success", (e: Event) => {
|
const event = e as IDBRequestEvent;
|
this.closeConnection();
|
resolve(event.target.result === 1);
|
});
|
|
dbContainsKey.addEventListener("error", (e: Event) => {
|
this.closeConnection();
|
reject(e);
|
});
|
});
|
}
|
|
/**
|
* Deletes the MSAL database. The database is deleted rather than cleared to make it possible
|
* for client applications to downgrade to a previous MSAL version without worrying about forward compatibility issues
|
* with IndexedDB database versions.
|
*/
|
async deleteDatabase(): Promise<boolean> {
|
// Check if database being deleted exists
|
|
if (this.db && this.dbOpen) {
|
this.closeConnection();
|
}
|
|
return new Promise<boolean>((resolve: Function, reject: Function) => {
|
const deleteDbRequest = window.indexedDB.deleteDatabase(DB_NAME);
|
const id = setTimeout(() => reject(false), 200); // Reject if events aren't raised within 200ms
|
deleteDbRequest.addEventListener("success", () => {
|
clearTimeout(id);
|
return resolve(true);
|
});
|
deleteDbRequest.addEventListener("blocked", () => {
|
clearTimeout(id);
|
return resolve(true);
|
});
|
deleteDbRequest.addEventListener("error", () => {
|
clearTimeout(id);
|
return reject(false);
|
});
|
});
|
}
|
}
|
