@ngx-pwa/local-storage
Version:
Efficient local storage module for Angular: simple API based on native localStorage API, but internally stored via the asynchronous IndexedDB API for performance, and wrapped in RxJS observables to be homogeneous with other Angular modules.
294 lines • 39.6 kB
JavaScript
import { Injectable, Inject } from '@angular/core';
import { throwError, of, ReplaySubject } from 'rxjs';
import { mergeMap, catchError, tap } from 'rxjs/operators';
import { JSONValidator } from '../validation/json-validator';
import { IndexedDBDatabase } from '../databases/indexeddb-database';
import { LocalStorageDatabase } from '../databases/localstorage-database';
import { MemoryDatabase } from '../databases/memory-database';
import { LocalDatabase } from '../databases/local-database';
import { IDB_BROKEN_ERROR } from '../databases/exceptions';
import { LS_PREFIX } from '../tokens';
import { ValidationError } from './exceptions';
import * as i0 from "@angular/core";
import * as i1 from "../databases/local-database";
import * as i2 from "../validation/json-validator";
import * as i3 from "../tokens";
export class StorageMap {
/**
* Constructor params are provided by Angular (but can also be passed manually in tests)
* @param database Storage to use
* @param jsonValidator Validator service
* @param LSPrefix Prefix for `localStorage` keys to avoid collision for multiple apps on the same subdomain or for interoperability
*/
constructor(database, jsonValidator = new JSONValidator(), LSPrefix = '') {
this.database = database;
this.jsonValidator = jsonValidator;
this.LSPrefix = LSPrefix;
this.notifiers = new Map();
}
/**
* **Number of items** in storage, wrapped in an `Observable`.
*
* @example
* this.storageMap.size.subscribe((size) => {
* console.log(size);
* });
*/
get size() {
return this.database.size
/* Catch if `indexedDb` is broken */
.pipe(this.catchIDBBroken(() => this.database.size));
}
/**
* Tells you which storage engine is used. *Only useful for interoperability.*
* Note that due to some browsers issues in some special contexts
* (Firefox private mode and Safari cross-origin iframes),
* **this information may be wrong at initialization,**
* as the storage could fallback from `indexedDB` to `localStorage`
* only after a first read or write operation.
* @returns Storage engine used
*
* @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/master/docs/INTEROPERABILITY.md}
*
* @example
* if (this.storageMap.backingEngine === 'indexedDB') {}
*/
get backingEngine() {
if (this.database instanceof IndexedDBDatabase) {
return 'indexedDB';
}
else if (this.database instanceof LocalStorageDatabase) {
return 'localStorage';
}
else if (this.database instanceof MemoryDatabase) {
return 'memory';
}
else {
return 'unknown';
}
}
/**
* Info about `indexedDB` database. *Only useful for interoperability.*
* @returns `indexedDB` database name, store name and database version.
* **Values will be empty if the storage is not `indexedDB`,**
* **so it should be used after an engine check**.
*
* @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/master/docs/INTEROPERABILITY.md}
*
* @example
* if (this.storageMap.backingEngine === 'indexedDB') {
* const { database, store, version } = this.storageMap.backingStore;
* }
*/
get backingStore() {
return (this.database instanceof IndexedDBDatabase) ?
this.database.backingStore :
{ database: '', store: '', version: 0 };
}
/**
* Info about `localStorage` fallback storage. *Only useful for interoperability.*
* @returns `localStorage` prefix.
* **Values will be empty if the storage is not `localStorage`,**
* **so it should be used after an engine check**.
*
* @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/master/docs/INTEROPERABILITY.md}
*
* @example
* if (this.storageMap.backingEngine === 'localStorage') {
* const { prefix } = this.storageMap.fallbackBackingStore;
* }
*/
get fallbackBackingStore() {
return (this.database instanceof LocalStorageDatabase) ?
{ prefix: this.database.prefix } :
{ prefix: '' };
}
get(key, schema) {
/* Get the data in storage */
return this.database.get(key).pipe(
/* Check if `indexedDb` is broken */
this.catchIDBBroken(() => this.database.get(key)), mergeMap((data) => {
/* No need to validate if the data is empty */
if ((data === undefined) || (data === null)) {
return of(undefined);
}
else if (schema) {
/* Validate data against a JSON schema if provided */
if (!this.jsonValidator.validate(data, schema)) {
return throwError(new ValidationError());
}
/* Data have been checked, so it's OK to cast */
return of(data);
}
/* Cast to unknown as the data wasn't checked */
return of(data);
}));
}
/**
* Set an item in storage.
* Note that setting `null` or `undefined` will remove the item to avoid some browsers issues.
* @param key The item's key
* @param data The item's value
* @param schema Optional JSON schema to validate the data
* @returns A RxJS `Observable` to wait the end of the operation
*
* @example
* this.storageMap.set('key', 'value').subscribe(() => {});
*/
set(key, data, schema) {
/* Storing `undefined` or `null` is useless and can cause issues in `indexedDb` in some browsers,
* so removing item instead for all storages to have a consistent API */
if ((data === undefined) || (data === null)) {
return this.delete(key);
}
/* Validate data against a JSON schema if provided */
if (schema && !this.jsonValidator.validate(data, schema)) {
return throwError(new ValidationError());
}
return this.database.set(key, data).pipe(
/* Catch if `indexedDb` is broken */
this.catchIDBBroken(() => this.database.set(key, data)),
/* Notify watchers (must be last because it should only happen if the operation succeeds) */
tap(() => { this.notify(key, data); }));
}
/**
* Delete an item in storage
* @param key The item's key
* @returns A RxJS `Observable` to wait the end of the operation
*
* @example
* this.storageMap.delete('key').subscribe(() => {});
*/
delete(key) {
return this.database.delete(key).pipe(
/* Catch if `indexedDb` is broken */
this.catchIDBBroken(() => this.database.delete(key)),
/* Notify watchers (must be last because it should only happen if the operation succeeds) */
tap(() => { this.notify(key, undefined); }));
}
/**
* Delete all items in storage
* @returns A RxJS `Observable` to wait the end of the operation
*
* @example
* this.storageMap.clear().subscribe(() => {});
*/
clear() {
return this.database.clear().pipe(
/* Catch if `indexedDb` is broken */
this.catchIDBBroken(() => this.database.clear()),
/* Notify watchers (must be last because it should only happen if the operation succeeds) */
tap(() => {
for (const key of this.notifiers.keys()) {
this.notify(key, undefined);
}
}));
}
/**
* Get all keys stored in storage. Note **this is an *iterating* `Observable`**:
* * if there is no key, the `next` callback will not be invoked,
* * if you need to wait the whole operation to end, be sure to act in the `complete` callback,
* as this `Observable` can emit several values and so will invoke the `next` callback several times.
* @returns A list of the keys wrapped in a RxJS `Observable`
*
* @example
* this.storageMap.keys().subscribe({
* next: (key) => { console.log(key); },
* complete: () => { console.log('Done'); },
* });
*/
keys() {
return this.database.keys()
/* Catch if `indexedDb` is broken */
.pipe(this.catchIDBBroken(() => this.database.keys()));
}
/**
* Tells if a key exists in storage
* @returns A RxJS `Observable` telling if the key exists
*
* @example
* this.storageMap.has('key').subscribe((hasKey) => {
* if (hasKey) {}
* });
*/
has(key) {
return this.database.has(key)
/* Catch if `indexedDb` is broken */
.pipe(this.catchIDBBroken(() => this.database.has(key)));
}
watch(key, schema) {
/* Check if there is already a notifier and cast according to schema */
let notifier = this.notifiers.get(key);
if (!notifier) {
/* Create a notifier and cast according to schema */
notifier = new ReplaySubject(1);
/* Memorize the notifier */
this.notifiers.set(key, notifier);
/* Get the current item value */
this.get(key, schema).subscribe({
next: (result) => notifier.next(result),
error: (error) => notifier.error(error),
});
}
/* Only the public API of the `Observable` should be returned */
return notifier.asObservable();
}
/**
* Notify when a value changes
* @param key The item's key
* @param data The new value
*/
notify(key, value) {
const notifier = this.notifiers.get(key);
if (notifier) {
notifier.next(value);
}
}
/**
* RxJS operator to catch if `indexedDB` is broken
* @param operationCallback Callback with the operation to redo
*/
catchIDBBroken(operationCallback) {
return catchError((error) => {
/* Check if `indexedDB` is broken based on error message (the specific error class seems to be lost in the process) */
if ((error !== undefined) && (error !== null) && (error.message === IDB_BROKEN_ERROR)) {
/* When storage is fully disabled in browser (via the "Block all cookies" option),
* just trying to check `localStorage` variable causes a security exception.
* Prevents https://github.com/cyrilletuzi/angular-async-local-storage/issues/118
*/
try {
if ('getItem' in localStorage) {
/* Fallback to `localStorage` if available */
this.database = new LocalStorageDatabase(this.LSPrefix);
}
else {
/* Fallback to memory storage otherwise */
this.database = new MemoryDatabase();
}
}
catch (_a) {
/* Fallback to memory storage otherwise */
this.database = new MemoryDatabase();
}
/* Redo the operation */
return operationCallback();
}
else {
/* Otherwise, rethrow the error */
return throwError(error);
}
});
}
}
StorageMap.ɵprov = i0.ɵɵdefineInjectable({ factory: function StorageMap_Factory() { return new StorageMap(i0.ɵɵinject(i1.LocalDatabase), i0.ɵɵinject(i2.JSONValidator), i0.ɵɵinject(i3.LS_PREFIX)); }, token: StorageMap, providedIn: "root" });
StorageMap.decorators = [
{ type: Injectable, args: [{
providedIn: 'root'
},] }
];
StorageMap.ctorParameters = () => [
{ type: LocalDatabase },
{ type: JSONValidator },
{ type: undefined, decorators: [{ type: Inject, args: [LS_PREFIX,] }] }
];
//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"storage-map.service.js","sourceRoot":"","sources":["../../../../../../projects/ngx-pwa/local-storage/src/lib/storages/storage-map.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { Injectable, Inject } from '@angular/core';\nimport { Observable, throwError, of, OperatorFunction, ReplaySubject } from 'rxjs';\nimport { mergeMap, catchError, tap } from 'rxjs/operators';\n\nimport {\n  JSONSchema, JSONSchemaBoolean, JSONSchemaInteger,\n  JSONSchemaNumber, JSONSchemaString, JSONSchemaArrayOf,\n} from '../validation/json-schema';\nimport { JSONValidator } from '../validation/json-validator';\nimport { IndexedDBDatabase } from '../databases/indexeddb-database';\nimport { LocalStorageDatabase } from '../databases/localstorage-database';\nimport { MemoryDatabase } from '../databases/memory-database';\nimport { LocalDatabase } from '../databases/local-database';\nimport { IDB_BROKEN_ERROR } from '../databases/exceptions';\nimport { LS_PREFIX } from '../tokens';\nimport { ValidationError } from './exceptions';\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class StorageMap {\n\n  protected notifiers = new Map<string, ReplaySubject<unknown>>();\n\n  /**\n   * Constructor params are provided by Angular (but can also be passed manually in tests)\n   * @param database Storage to use\n   * @param jsonValidator Validator service\n   * @param LSPrefix Prefix for `localStorage` keys to avoid collision for multiple apps on the same subdomain or for interoperability\n   */\n  constructor(\n    protected database: LocalDatabase,\n    protected jsonValidator: JSONValidator = new JSONValidator(),\n    @Inject(LS_PREFIX) protected LSPrefix = '',\n  ) {}\n\n  /**\n   * **Number of items** in storage, wrapped in an `Observable`.\n   *\n   * @example\n   * this.storageMap.size.subscribe((size) => {\n   *   console.log(size);\n   * });\n   */\n  get size(): Observable<number> {\n\n    return this.database.size\n      /* Catch if `indexedDb` is broken */\n      .pipe(this.catchIDBBroken(() => this.database.size));\n\n  }\n\n  /**\n   * Tells you which storage engine is used. *Only useful for interoperability.*\n   * Note that due to some browsers issues in some special contexts\n   * (Firefox private mode and Safari cross-origin iframes),\n   * **this information may be wrong at initialization,**\n   * as the storage could fallback from `indexedDB` to `localStorage`\n   * only after a first read or write operation.\n   * @returns Storage engine used\n   *\n   * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/master/docs/INTEROPERABILITY.md}\n   *\n   * @example\n   * if (this.storageMap.backingEngine === 'indexedDB') {}\n   */\n  get backingEngine(): 'indexedDB' | 'localStorage' | 'memory' | 'unknown' {\n\n    if (this.database instanceof IndexedDBDatabase) {\n\n      return 'indexedDB';\n\n    } else if (this.database instanceof LocalStorageDatabase) {\n\n      return 'localStorage';\n\n    } else if (this.database instanceof MemoryDatabase) {\n\n      return 'memory';\n\n    } else {\n\n      return 'unknown';\n\n    }\n\n  }\n\n  /**\n   * Info about `indexedDB` database. *Only useful for interoperability.*\n   * @returns `indexedDB` database name, store name and database version.\n   * **Values will be empty if the storage is not `indexedDB`,**\n   * **so it should be used after an engine check**.\n   *\n   * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/master/docs/INTEROPERABILITY.md}\n   *\n   * @example\n   * if (this.storageMap.backingEngine === 'indexedDB') {\n   *   const { database, store, version } = this.storageMap.backingStore;\n   * }\n   */\n  get backingStore(): { database: string, store: string, version: number } {\n\n    return (this.database instanceof IndexedDBDatabase) ?\n      this.database.backingStore :\n      { database: '', store: '', version: 0 };\n\n  }\n\n  /**\n   * Info about `localStorage` fallback storage. *Only useful for interoperability.*\n   * @returns `localStorage` prefix.\n   * **Values will be empty if the storage is not `localStorage`,**\n   * **so it should be used after an engine check**.\n   *\n   * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/master/docs/INTEROPERABILITY.md}\n   *\n   * @example\n   * if (this.storageMap.backingEngine === 'localStorage') {\n   *   const { prefix } = this.storageMap.fallbackBackingStore;\n   * }\n   */\n  get fallbackBackingStore(): { prefix: string } {\n\n    return (this.database instanceof LocalStorageDatabase) ?\n      { prefix: this.database.prefix } :\n      { prefix: '' };\n\n  }\n\n  /**\n   * Get an item value in storage.\n   * The signature has many overloads due to validation, **please refer to the documentation.**\n   * @see {@link https://github.com/cyrilletuzi/angular-async-local-storage/blob/master/docs/VALIDATION.md}\n   * @param key The item's key\n   * @param schema Optional JSON schema to validate the data\n   * @returns The item's value if the key exists, `undefined` otherwise, wrapped in a RxJS `Observable`\n   *\n   * @example\n   * this.storageMap.get('key', { type: 'string' }).subscribe((result) => {\n   *   result; // string or undefined\n   * });\n   *\n   * @example\n   * interface User {\n   *   firstName: string;\n   *   lastName?: string;\n   * }\n   *\n   * const schema = {\n   *   type: 'object',\n   *   properties: {\n   *     firstName: { type: 'string' },\n   *     lastName: { type: 'string' },\n   *   },\n   *   required: ['firstName']\n   * };\n   *\n   * this.storageMap.get<User>('user', schema).subscribe((user) => {\n   *   if (user) {\n   *     user.firstName;\n   *   }\n   * });\n   */\n  get<T = string>(key: string, schema: JSONSchemaString): Observable<string | undefined>;\n  get<T = number>(key: string, schema: JSONSchemaInteger | JSONSchemaNumber): Observable<number | undefined>;\n  get<T = boolean>(key: string, schema: JSONSchemaBoolean): Observable<boolean | undefined>;\n  get<T = string[]>(key: string, schema: JSONSchemaArrayOf<JSONSchemaString>): Observable<string[] | undefined>;\n  get<T = number[]>(key: string, schema: JSONSchemaArrayOf<JSONSchemaInteger | JSONSchemaNumber>): Observable<number[] | undefined>;\n  get<T = boolean[]>(key: string, schema: JSONSchemaArrayOf<JSONSchemaBoolean>): Observable<boolean[] | undefined>;\n  get<T = unknown>(key: string, schema: JSONSchema): Observable<T | undefined>;\n  get<T = unknown>(key: string, schema?: JSONSchema): Observable<unknown>;\n  get<T = unknown>(key: string, schema?: JSONSchema): Observable<unknown> {\n\n    /* Get the data in storage */\n    return this.database.get<T>(key).pipe(\n      /* Check if `indexedDb` is broken */\n      this.catchIDBBroken(() => this.database.get<T>(key)),\n      mergeMap((data) => {\n\n        /* No need to validate if the data is empty */\n        if ((data === undefined) || (data === null)) {\n\n          return of(undefined);\n\n        } else if (schema) {\n\n          /* Validate data against a JSON schema if provided */\n          if (!this.jsonValidator.validate(data, schema)) {\n            return throwError(new ValidationError());\n          }\n\n          /* Data have been checked, so it's OK to cast */\n          return of(data as T | undefined);\n\n        }\n\n        /* Cast to unknown as the data wasn't checked */\n        return of(data as unknown);\n\n      }),\n    );\n\n  }\n\n  /**\n   * Set an item in storage.\n   * Note that setting `null` or `undefined` will remove the item to avoid some browsers issues.\n   * @param key The item's key\n   * @param data The item's value\n   * @param schema Optional JSON schema to validate the data\n   * @returns A RxJS `Observable` to wait the end of the operation\n   *\n   * @example\n   * this.storageMap.set('key', 'value').subscribe(() => {});\n   */\n  set(key: string, data: unknown, schema?: JSONSchema): Observable<undefined> {\n\n    /* Storing `undefined` or `null` is useless and can cause issues in `indexedDb` in some browsers,\n     * so removing item instead for all storages to have a consistent API */\n    if ((data === undefined) || (data === null)) {\n      return this.delete(key);\n    }\n\n    /* Validate data against a JSON schema if provided */\n    if (schema && !this.jsonValidator.validate(data, schema)) {\n      return throwError(new ValidationError());\n    }\n\n    return this.database.set(key, data).pipe(\n      /* Catch if `indexedDb` is broken */\n      this.catchIDBBroken(() => this.database.set(key, data)),\n      /* Notify watchers (must be last because it should only happen if the operation succeeds) */\n      tap(() => { this.notify(key, data); }),\n    );\n  }\n\n  /**\n   * Delete an item in storage\n   * @param key The item's key\n   * @returns A RxJS `Observable` to wait the end of the operation\n   *\n   * @example\n   * this.storageMap.delete('key').subscribe(() => {});\n   */\n  delete(key: string): Observable<undefined> {\n\n    return this.database.delete(key).pipe(\n      /* Catch if `indexedDb` is broken */\n      this.catchIDBBroken(() => this.database.delete(key)),\n      /* Notify watchers (must be last because it should only happen if the operation succeeds) */\n      tap(() => { this.notify(key, undefined); }),\n    );\n\n  }\n\n  /**\n   * Delete all items in storage\n   * @returns A RxJS `Observable` to wait the end of the operation\n   *\n   * @example\n   * this.storageMap.clear().subscribe(() => {});\n   */\n  clear(): Observable<undefined> {\n\n    return this.database.clear().pipe(\n      /* Catch if `indexedDb` is broken */\n      this.catchIDBBroken(() => this.database.clear()),\n      /* Notify watchers (must be last because it should only happen if the operation succeeds) */\n      tap(() => {\n        for (const key of this.notifiers.keys()) {\n          this.notify(key, undefined);\n        }\n      }),\n    );\n\n  }\n\n  /**\n   * Get all keys stored in storage. Note **this is an *iterating* `Observable`**:\n   * * if there is no key, the `next` callback will not be invoked,\n   * * if you need to wait the whole operation to end, be sure to act in the `complete` callback,\n   * as this `Observable` can emit several values and so will invoke the `next` callback several times.\n   * @returns A list of the keys wrapped in a RxJS `Observable`\n   *\n   * @example\n   * this.storageMap.keys().subscribe({\n   *   next: (key) => { console.log(key); },\n   *   complete: () => { console.log('Done'); },\n   * });\n   */\n  keys(): Observable<string> {\n\n    return this.database.keys()\n      /* Catch if `indexedDb` is broken */\n      .pipe(this.catchIDBBroken(() => this.database.keys()));\n\n  }\n\n  /**\n   * Tells if a key exists in storage\n   * @returns A RxJS `Observable` telling if the key exists\n   *\n   * @example\n   * this.storageMap.has('key').subscribe((hasKey) => {\n   *   if (hasKey) {}\n   * });\n   */\n  has(key: string): Observable<boolean> {\n\n    return this.database.has(key)\n      /* Catch if `indexedDb` is broken */\n      .pipe(this.catchIDBBroken(() => this.database.has(key)));\n\n  }\n\n  /**\n   * Watch an item value in storage.\n   * **Note only changes done via this lib will be watched**, external changes in storage can't be detected.\n   * The signature has many overloads due to validation, **please refer to the documentation.**\n   * @see https://github.com/cyrilletuzi/angular-async-local-storage/blob/master/docs/VALIDATION.md\n   * @param key The item's key to watch\n   * @param schema Optional JSON schema to validate the initial value\n   * @returns An infinite `Observable` giving the current value\n   */\n  watch<T = string>(key: string, schema: JSONSchemaString): Observable<string | undefined>;\n  watch<T = number>(key: string, schema: JSONSchemaInteger | JSONSchemaNumber): Observable<number | undefined>;\n  watch<T = boolean>(key: string, schema: JSONSchemaBoolean): Observable<boolean | undefined>;\n  watch<T = string[]>(key: string, schema: JSONSchemaArrayOf<JSONSchemaString>): Observable<string[] | undefined>;\n  watch<T = number[]>(key: string, schema: JSONSchemaArrayOf<JSONSchemaInteger | JSONSchemaNumber>): Observable<number[] | undefined>;\n  watch<T = boolean[]>(key: string, schema: JSONSchemaArrayOf<JSONSchemaBoolean>): Observable<boolean[] | undefined>;\n  watch<T = unknown>(key: string, schema: JSONSchema): Observable<T | undefined>;\n  watch<T = unknown>(key: string, schema?: JSONSchema): Observable<unknown>;\n  watch<T = unknown>(key: string, schema?: JSONSchema): Observable<unknown> {\n\n    /* Check if there is already a notifier and cast according to schema */\n    let notifier = this.notifiers.get(key) as ReplaySubject<typeof schema extends JSONSchema ? (T | undefined) : unknown>;\n\n    if (!notifier) {\n\n      /* Create a notifier and cast according to schema */\n      notifier = new ReplaySubject<typeof schema extends JSONSchema ? (T | undefined) : unknown>(1);\n\n      /* Memorize the notifier */\n      this.notifiers.set(key, notifier);\n\n      /* Get the current item value */\n      this.get<T>(key, schema).subscribe({\n        next: (result) => notifier.next(result),\n        error: (error) => notifier.error(error),\n      });\n\n    }\n\n    /* Only the public API of the `Observable` should be returned */\n    return notifier.asObservable();\n\n  }\n\n  /**\n   * Notify when a value changes\n   * @param key The item's key\n   * @param data The new value\n   */\n  protected notify(key: string, value: unknown): void {\n\n    const notifier = this.notifiers.get(key);\n\n    if (notifier) {\n      notifier.next(value);\n    }\n\n  }\n\n  /**\n   * RxJS operator to catch if `indexedDB` is broken\n   * @param operationCallback Callback with the operation to redo\n   */\n  protected catchIDBBroken<T>(operationCallback: () => Observable<T>): OperatorFunction<T, T> {\n\n    return catchError((error) => {\n\n      /* Check if `indexedDB` is broken based on error message (the specific error class seems to be lost in the process) */\n      if ((error !== undefined) && (error !== null) && (error.message === IDB_BROKEN_ERROR)) {\n\n        /* When storage is fully disabled in browser (via the \"Block all cookies\" option),\n         * just trying to check `localStorage` variable causes a security exception.\n         * Prevents https://github.com/cyrilletuzi/angular-async-local-storage/issues/118\n         */\n        try {\n\n          if ('getItem' in localStorage) {\n\n            /* Fallback to `localStorage` if available */\n            this.database = new LocalStorageDatabase(this.LSPrefix);\n\n          } else {\n\n            /* Fallback to memory storage otherwise */\n            this.database = new MemoryDatabase();\n\n          }\n\n        } catch {\n\n          /* Fallback to memory storage otherwise */\n          this.database = new MemoryDatabase();\n\n        }\n\n        /* Redo the operation */\n        return operationCallback();\n\n      } else {\n\n        /* Otherwise, rethrow the error */\n        return throwError(error);\n\n      }\n\n    });\n\n  }\n\n}\n"]}