tsbase/Persistence/IndexedDb/IndexedDb.js

Base class libraries for TypeScript

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
exports.IndexedDb = void 0;
const Until_1 = require("../../Utility/Timers/Until");
const module_1 = require("../../Patterns/CommandQuery/module");
const TransactionModes_1 = require("./TransactionModes");
class IndexedDb {
    static Instance(name, version, migrations, indexedDbFactory = indexedDB) {
        return new IndexedDb(name, version, migrations, indexedDbFactory);
    }
    get Connected() {
        return !!this.database;
    }
    ;
    constructor(Name, Version, migrations, indexedDbFactory) {
        this.Name = Name;
        this.Version = Version;
        this.migrations = migrations;
        this.indexedDbFactory = indexedDbFactory;
        this.database = null;
    }
    async Connect() {
        return new module_1.AsyncQuery(async () => {
            if (this.Connected) {
                return this.database;
            }
            else {
                const openRequest = this.indexedDbFactory.open(this.Name, this.Version);
                this.setOpenRequestHandlers(openRequest, this.migrations);
                await (0, Until_1.Until)(() => this.Connected);
                return this.database;
            }
        }).Execute();
    }
    Insert(insertions) {
        const storeNames = Object.keys(insertions);
        return this.executeTransaction(storeNames, (transaction) => {
            storeNames.forEach(storeName => {
                const store = transaction.objectStore(storeName);
                const objects = insertions[storeName];
                objects.forEach(object => {
                    store.add(object);
                });
            });
        });
    }
    Get(storeName, query) {
        return new module_1.AsyncQuery(async () => {
            await this.Connect();
            let complete = false;
            let result = null;
            const transaction = this.database.transaction([storeName], TransactionModes_1.TransactionMode.ReadOnly);
            const store = transaction.objectStore(storeName);
            if (typeof query === 'string' || typeof query === 'number') {
                const request = store.get(query);
                request.onsuccess = () => {
                    result = request.result || null;
                    complete = true;
                };
            }
            else {
                store.openCursor().onsuccess = (event) => {
                    result = result ? result : new Array();
                    const cursor = event.target.result;
                    if (cursor && query(cursor['value'])) {
                        result.push(cursor.value);
                        cursor.continue();
                    }
                    else if (cursor) {
                        cursor.continue();
                    }
                    else {
                        complete = true;
                    }
                };
            }
            await (0, Until_1.Until)(() => complete);
            return result;
        }).Execute();
    }
    GetAll(storeName) {
        return new module_1.AsyncQuery(async () => {
            await this.Connect();
            let complete = false;
            let result = new Array();
            const request = this.database.transaction([storeName], TransactionModes_1.TransactionMode.ReadOnly)
                .objectStore(storeName)
                .getAll();
            request.onsuccess = (event) => {
                result = event.target.result;
                complete = true;
            };
            await (0, Until_1.Until)(() => complete);
            return result;
        }).Execute();
    }
    Delete(deletions) {
        const storeNames = Object.keys(deletions);
        return this.executeTransaction(storeNames, (transaction) => {
            storeNames.forEach(storeName => {
                const store = transaction.objectStore(storeName);
                const keys = deletions[storeName];
                keys.forEach(key => {
                    store.delete(key);
                });
            });
        });
    }
    Update(updates) {
        const storeNames = Object.keys(updates);
        return this.executeTransaction(storeNames, (transaction) => {
            storeNames.forEach(storeName => {
                const store = transaction.objectStore(storeName);
                const objects = updates[storeName];
                objects.forEach(object => {
                    store.put(object);
                });
            });
        });
    }
    Disconnect() {
        var _a;
        (_a = this.database) === null || _a === void 0 ? void 0 : _a.close();
        this.database = null;
    }
    setOpenRequestHandlers(openRequest, migrations) {
        openRequest.onupgradeneeded = async (e) => {
            const db = openRequest.result;
            for (const migration of migrations) {
                if (e.oldVersion < migration.version &&
                    this.Version >= migration.version) {
                    migration.command(db);
                }
            }
        };
        openRequest.onsuccess = () => this.database = openRequest.result;
    }
    executeTransaction(storeNames, command) {
        return new module_1.AsyncCommand(async () => {
            await this.Connect();
            let complete = false;
            const transaction = this.database.transaction(storeNames, TransactionModes_1.TransactionMode.ReadWrite);
            command(transaction);
            transaction.oncomplete = () => complete = true;
            await (0, Until_1.Until)(() => complete);
        }).Execute();
    }
}
exports.IndexedDb = IndexedDb;
//# sourceMappingURL=IndexedDb.js.map