@nu-art/thunderstorm-frontend 0.400.5

package/core/IndexedDB.js

@@ -0,0 +1,259 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { MUSTNeverHappenException, StaticLogger } from '@nu-art/ts-common';
+//@ts-ignore - set IDBAPI as indexedDB regardless of browser
+const IDBAPI = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+export class IndexedDB {
+    db;
+    config;
+    static dbs = {};
+    static getOrCreate(config) {
+        return this.dbs[config.name] || (this.dbs[config.name] = new IndexedDB(config));
+    }
+    constructor(config) {
+        this.config = {
+            ...config,
+            upgradeProcessor: (db) => {
+                if (!db.objectStoreNames.contains(this.config.name)) {
+                    const store = db.createObjectStore(this.config.name, {
+                        autoIncrement: config.autoIncrement,
+                        keyPath: config.uniqueKeys
+                    });
+                    this.config.indices?.forEach(index => store.createIndex(index.id, index.keys, {
+                        multiEntry: index.params?.multiEntry,
+                        unique: index.params?.unique
+                    }));
+                }
+                config.upgradeProcessor?.(db);
+            },
+            autoIncrement: config.autoIncrement || false,
+            version: config.version || 1
+        };
+    }
+    async exists() {
+        return (await window.indexedDB.databases()).find(db => db.name === this.config.name);
+    }
+    async open() {
+        return new Promise((resolve, reject) => {
+            if (!IDBAPI)
+                reject(new Error('Error - current browser does not support IndexedDB'));
+            const request = IDBAPI.open(this.config.name);
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                this.config.upgradeProcessor?.(db);
+            };
+            request.onsuccess = (event) => {
+                // console.log(`${this.config.name} - IDB result`, request.result);
+                this.db = request.result;
+                resolve(this.db);
+            };
+            request.onerror = (event) => {
+                reject(new Error(`Error opening IDB - ${this.config.name}`));
+            };
+        });
+    }
+    store = async (write = false, store) => {
+        if (store)
+            return store;
+        if (!this.db)
+            await this.open();
+        return this.db.transaction(this.config.name, write ? 'readwrite' : 'readonly').objectStore(this.config.name);
+    };
+    getCursor = async (query) => {
+        const store = await this.store();
+        let cursorRequest;
+        if (query?.indexKey) {
+            const idbIndex = store.index(query.indexKey);
+            if (!idbIndex)
+                throw new MUSTNeverHappenException('Could not find index for the given indexKey');
+            cursorRequest = idbIndex.openCursor();
+        }
+        else
+            cursorRequest = store.openCursor();
+        return cursorRequest;
+    };
+    cursorHandler = (cursorRequest, perValueCallback, endCallback, limiterCallback) => {
+        cursorRequest.onsuccess = (event) => {
+            const cursor = event.target.result;
+            //If reached the end or reached limit, call endCallback
+            if (!cursor || limiterCallback?.())
+                return endCallback();
+            //run value through the value callback
+            perValueCallback(cursor.value);
+            //Continue to next value
+            cursor.continue();
+        };
+    };
+    // ######################### Data insertion functions #########################
+    async insert(value, _store) {
+        const store = await this.store(true, _store);
+        const request = store.add(value);
+        return new Promise((resolve, reject) => {
+            request.onerror = () => reject(new Error(`Error inserting item in DB - ${this.config.name}`));
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async insertAll(values, _store) {
+        const store = await this.store(true, _store);
+        for (const value of values) {
+            await this.insert(value, store);
+        }
+    }
+    async upsert(value, _store) {
+        const store = await this.store(true, _store);
+        try {
+            const request = store.put(value);
+            return new Promise((resolve, reject) => {
+                request.onerror = () => reject(new Error(`Error upserting item in DB - ${this.config.name}`));
+                request.onsuccess = () => resolve(request.result);
+            });
+        }
+        catch (e) {
+            StaticLogger.logError('trying to upsert: ', value);
+            throw e;
+        }
+    }
+    async upsertAll(values, _store) {
+        const store = (await this.store(true, _store));
+        for (const value of values) {
+            await this.upsert(value, store);
+        }
+    }
+    // ######################### Data collection functions #########################
+    async get(key) {
+        const map = this.config.uniqueKeys.map(k => key[k]);
+        const request = (await this.store()).get(map);
+        return new Promise((resolve, reject) => {
+            request.onerror = () => reject(new Error(`Error getting item from DB - ${this.config.name}`));
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async query(query) {
+        const store = await this.store();
+        return new Promise((resolve, reject) => {
+            let request;
+            if (query.indexKey)
+                request = store.index(query.indexKey).getAll(query.query, query.limit);
+            else
+                request = store.getAll(query.query, query.limit);
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+            request.onerror = () => {
+                reject(new Error(`Error querying DB - ${this.config.name}`));
+            };
+        });
+    }
+    async queryFilter(filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve) => {
+            this.cursorHandler(cursorRequest, (value) => {
+                if (filter(value))
+                    matches.push(value);
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async WIP_queryMapNew(mapper, filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (item) => {
+                if (filter ? filter(item) : true)
+                    matches.push(mapper(item));
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async WIP_queryMap(mapper, filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve) => {
+            this.cursorHandler(cursorRequest, (item) => {
+                if (filter ? filter(item) : true)
+                    matches.push(mapper(item));
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async queryFind(filter) {
+        let match = undefined;
+        const cursorRequest = await this.getCursor();
+        return new Promise((resolve) => {
+            this.cursorHandler(cursorRequest, (value) => {
+                if (filter(value))
+                    match = value;
+            }, () => resolve(match), () => !!match);
+        });
+    }
+    async queryReduce(reducer, initialValue, filter, query) {
+        let acc = initialValue;
+        const alwaysTrue = () => true;
+        const _filter = filter || alwaysTrue;
+        const matches = await this.queryFilter(_filter, query);
+        return new Promise((resolve) => {
+            matches.forEach((item, index) => acc = reducer(acc, item, index, matches));
+            resolve(acc);
+        });
+    }
+    // ######################### Data deletion functions #########################
+    async clearDB() {
+        const store = await this.store(true);
+        return new Promise((resolve, reject) => {
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = reject;
+        });
+    }
+    async deleteDB() {
+        if (this.db)
+            this.db.close();
+        return new Promise((resolve, reject) => {
+            const request = IDBAPI.deleteDatabase(this.db.name);
+            request.onerror = (event) => {
+                StaticLogger.logError(`Error deleting database: ${this.db.name}`);
+                reject();
+            };
+            request.onsuccess = () => resolve();
+        });
+    }
+    async deleteAll(keys) {
+        return await Promise.all(keys.map(key => this.delete(key)));
+    }
+    async delete(key) {
+        const keys = this.config.uniqueKeys.map(k => key[k]);
+        const store = await this.store(true);
+        return new Promise((resolve, reject) => {
+            const itemRequest = store.get(keys);
+            itemRequest.onerror = () => reject(new Error(`Error getting item in DB - ${this.config.name}`));
+            itemRequest.onsuccess = () => {
+                // @ts-ignore
+                if (key.__updated !== undefined && itemRequest.result?.__updated > key.__updated) {
+                    return resolve(itemRequest.result);
+                }
+                const deleteRequest = store.delete(keys);
+                deleteRequest.onerror = () => reject(new Error(`Error deleting item in DB - ${this.config.name}`));
+                deleteRequest.onsuccess = () => resolve(itemRequest.result);
+            };
+        });
+    }
+}

package/core/IndexedDBV3.d.ts

@@ -0,0 +1,43 @@
+import { DBIndex, DBProto, IndexKeys } from '@nu-art/ts-common';
+export type ReduceFunction_V3<ItemType, ReturnType> = (accumulator: ReturnType, arrayItem: ItemType, index?: number, array?: ItemType[]) => ReturnType;
+export type DBConfigV3<Proto extends DBProto<any>> = {
+    name: string;
+    group: string;
+    version?: number;
+    autoIncrement?: boolean;
+    uniqueKeys: (keyof Proto['dbType'])[];
+    indices?: DBIndex<Proto['dbType']>[];
+    upgradeProcessor?: (db: IDBDatabase) => void;
+};
+export type IndexDb_Query_V3 = {
+    query?: string | number | string[] | number[];
+    indexKey?: string;
+    limit?: number;
+};
+export declare class IndexedDBV3<Proto extends DBProto<any>> {
+    private db;
+    private config;
+    private static dbs;
+    static getOrCreate<Proto extends DBProto<any>>(config: DBConfigV3<Proto>): IndexedDBV3<Proto>;
+    constructor(config: DBConfigV3<Proto>);
+    exists(): Promise<IDBDatabaseInfo | undefined>;
+    open(): Promise<IDBDatabase>;
+    readonly store: (write?: boolean, store?: IDBObjectStore) => Promise<IDBObjectStore>;
+    private getCursor;
+    private cursorHandler;
+    insert(value: Proto['dbType'], _store?: IDBObjectStore): Promise<Proto['dbType']>;
+    insertAll(values: Proto['dbType'][], _store?: IDBObjectStore): Promise<void>;
+    upsert(value: Proto['dbType'], _store?: IDBObjectStore): Promise<Proto['dbType']>;
+    upsertAll(values: Proto['dbType'][], _store?: IDBObjectStore): Promise<void>;
+    get(key: IndexKeys<Proto['dbType'], keyof Proto['dbType']>): Promise<Proto['dbType'] | undefined>;
+    query(query: IndexDb_Query_V3): Promise<Proto['dbType'][] | undefined>;
+    queryFilter(filter: (item: Proto['dbType']) => boolean, query?: IndexDb_Query_V3): Promise<Proto['dbType'][]>;
+    WIP_queryMapNew<Type>(mapper: (item: Proto['dbType']) => Type, filter?: (item: Proto['dbType']) => boolean, query?: IndexDb_Query_V3): Promise<Type[]>;
+    WIP_queryMap<Type>(mapper: (item: Proto['dbType']) => Type, filter?: (item: Proto['dbType']) => boolean, query?: IndexDb_Query_V3): Promise<Type[]>;
+    queryFind(filter: (item: Proto['dbType']) => boolean): Promise<Proto['dbType'] | undefined>;
+    queryReduce<ReturnType>(reducer: ReduceFunction_V3<Proto['dbType'], ReturnType>, initialValue: ReturnType, filter?: (item: Proto['dbType']) => boolean, query?: IndexDb_Query_V3): Promise<ReturnType>;
+    clearDB(): Promise<void>;
+    deleteDB(): Promise<void>;
+    deleteAll(keys: (IndexKeys<Proto['dbType'], keyof Proto['dbType']> | Proto['dbType'])[]): Promise<Proto['dbType'][]>;
+    delete(key: (IndexKeys<Proto['dbType'], keyof Proto['dbType']> | Proto['dbType'])): Promise<Proto['dbType']>;
+}

package/core/IndexedDBV3.js

@@ -0,0 +1,259 @@
+/*
+ * Thunderstorm is a full web app framework!
+ *
+ * Typescript & Express backend infrastructure that natively runs on firebase function
+ * Typescript & React frontend infrastructure
+ *
+ * Copyright (C) 2020 Adam van der Kruk aka TacB0sS
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import { MUSTNeverHappenException, StaticLogger } from '@nu-art/ts-common';
+//@ts-ignore - set IDBAPI as indexedDB regardless of browser
+const IDBAPI = window.indexedDB || window.mozIndexedDB || window.webkitIndexedDB || window.msIndexedDB;
+export class IndexedDBV3 {
+    db;
+    config;
+    static dbs = {};
+    static getOrCreate(config) {
+        return this.dbs[config.name] || (this.dbs[config.name] = new IndexedDBV3(config));
+    }
+    constructor(config) {
+        this.config = {
+            ...config,
+            upgradeProcessor: (db) => {
+                if (!db.objectStoreNames.contains(this.config.name)) {
+                    const store = db.createObjectStore(this.config.name, {
+                        autoIncrement: config.autoIncrement,
+                        keyPath: config.uniqueKeys
+                    });
+                    this.config.indices?.forEach(index => store.createIndex(index.id, index.keys, {
+                        multiEntry: index.params?.multiEntry,
+                        unique: index.params?.unique
+                    }));
+                }
+                config.upgradeProcessor?.(db);
+            },
+            autoIncrement: config.autoIncrement || false,
+            version: config.version || 1
+        };
+    }
+    async exists() {
+        return (await window.indexedDB.databases()).find(db => db.name === this.config.name);
+    }
+    async open() {
+        return new Promise((resolve, reject) => {
+            if (!IDBAPI)
+                reject(new Error('Error - current browser does not support IndexedDB'));
+            const request = IDBAPI.open(this.config.name);
+            request.onupgradeneeded = () => {
+                const db = request.result;
+                this.config.upgradeProcessor?.(db);
+            };
+            request.onsuccess = () => {
+                // console.log(`${this.config.name} - IDB result`, request.result);
+                this.db = request.result;
+                resolve(this.db);
+            };
+            request.onerror = () => {
+                reject(new Error(`Error opening IDB - ${this.config.name}`));
+            };
+        });
+    }
+    store = async (write = false, store) => {
+        if (store)
+            return store;
+        if (!this.db)
+            await this.open();
+        return this.db.transaction(this.config.name, write ? 'readwrite' : 'readonly').objectStore(this.config.name);
+    };
+    getCursor = async (query) => {
+        const store = await this.store();
+        let cursorRequest;
+        if (query?.indexKey) {
+            const idbIndex = store.index(query.indexKey);
+            if (!idbIndex)
+                throw new MUSTNeverHappenException('Could not find index for the given indexKey');
+            cursorRequest = idbIndex.openCursor();
+        }
+        else
+            cursorRequest = store.openCursor();
+        return cursorRequest;
+    };
+    cursorHandler = (cursorRequest, perValueCallback, endCallback, limiterCallback) => {
+        cursorRequest.onsuccess = (event) => {
+            const cursor = event.target.result;
+            //If reached the end or reached limit, call endCallback
+            if (!cursor || limiterCallback?.())
+                return endCallback();
+            //run value through the value callback
+            perValueCallback(cursor.value);
+            //Continue to next value
+            cursor.continue();
+        };
+    };
+    // ######################### Data insertion functions #########################
+    async insert(value, _store) {
+        const store = await this.store(true, _store);
+        const request = store.add(value);
+        return new Promise((resolve, reject) => {
+            request.onerror = () => reject(new Error(`Error inserting item in DB - ${this.config.name}`));
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async insertAll(values, _store) {
+        const store = await this.store(true, _store);
+        for (const value of values) {
+            await this.insert(value, store);
+        }
+    }
+    async upsert(value, _store) {
+        const store = await this.store(true, _store);
+        try {
+            const request = store.put(value);
+            return new Promise((resolve, reject) => {
+                request.onerror = () => reject(new Error(`Error upserting item in DB - ${this.config.name}`));
+                request.onsuccess = () => resolve(request.result);
+            });
+        }
+        catch (e) {
+            StaticLogger.logError('trying to upsert: ', value);
+            throw e;
+        }
+    }
+    async upsertAll(values, _store) {
+        const store = (await this.store(true, _store));
+        for (const value of values) {
+            await this.upsert(value, store);
+        }
+    }
+    // ######################### Data collection functions #########################
+    async get(key) {
+        const map = this.config.uniqueKeys.map(k => key[k]);
+        const request = (await this.store()).get(map);
+        return new Promise((resolve, reject) => {
+            request.onerror = () => reject(new Error(`Error getting item from DB - ${this.config.name}`));
+            request.onsuccess = () => resolve(request.result);
+        });
+    }
+    async query(query) {
+        const store = await this.store();
+        return new Promise((resolve, reject) => {
+            let request;
+            if (query.indexKey)
+                request = store.index(query.indexKey).getAll(query.query, query.limit);
+            else
+                request = store.getAll(query.query, query.limit);
+            request.onsuccess = () => {
+                resolve(request.result);
+            };
+            request.onerror = () => {
+                reject(new Error(`Error querying DB - ${this.config.name}`));
+            };
+        });
+    }
+    async queryFilter(filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (value) => {
+                if (filter(value))
+                    matches.push(value);
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async WIP_queryMapNew(mapper, filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (item) => {
+                if (filter ? filter(item) : true)
+                    matches.push(mapper(item));
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async WIP_queryMap(mapper, filter, query) {
+        const limit = query?.limit || 0;
+        const cursorRequest = await this.getCursor(query);
+        const matches = [];
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (item) => {
+                if (filter ? filter(item) : true)
+                    matches.push(mapper(item));
+            }, () => resolve(matches), () => limit > 0 && matches.length >= limit);
+        });
+    }
+    async queryFind(filter) {
+        let match = undefined;
+        const cursorRequest = await this.getCursor();
+        return new Promise((resolve, reject) => {
+            this.cursorHandler(cursorRequest, (value) => {
+                if (filter(value))
+                    match = value;
+            }, () => resolve(match), () => !!match);
+        });
+    }
+    async queryReduce(reducer, initialValue, filter, query) {
+        let acc = initialValue;
+        const alwaysTrue = () => true;
+        const _filter = filter || alwaysTrue;
+        const matches = await this.queryFilter(_filter, query);
+        return new Promise((resolve, reject) => {
+            matches.forEach((item, index) => acc = reducer(acc, item, index, matches));
+            resolve(acc);
+        });
+    }
+    // ######################### Data deletion functions #########################
+    async clearDB() {
+        const store = await this.store(true);
+        return new Promise((resolve, reject) => {
+            const request = store.clear();
+            request.onsuccess = () => resolve();
+            request.onerror = reject;
+        });
+    }
+    async deleteDB() {
+        if (this.db)
+            this.db.close();
+        return new Promise((resolve, reject) => {
+            const request = IDBAPI.deleteDatabase(this.db.name);
+            request.onerror = (event) => {
+                StaticLogger.logError(`Error deleting database: ${this.db.name}`);
+                reject();
+            };
+            request.onsuccess = () => resolve();
+        });
+    }
+    async deleteAll(keys) {
+        return await Promise.all(keys.map(key => this.delete(key)));
+    }
+    async delete(key) {
+        const keys = this.config.uniqueKeys.map(k => key[k]);
+        const store = await this.store(true);
+        return new Promise((resolve, reject) => {
+            const itemRequest = store.get(keys);
+            itemRequest.onerror = () => reject(new Error(`Error getting item in DB - ${this.config.name}`));
+            itemRequest.onsuccess = () => {
+                // @ts-ignore
+                if (key.__updated !== undefined && itemRequest.result?.__updated > key.__updated) {
+                    return resolve(itemRequest.result);
+                }
+                const deleteRequest = store.delete(keys);
+                deleteRequest.onerror = () => reject(new Error(`Error deleting item in DB - ${this.config.name}`));
+                deleteRequest.onsuccess = () => resolve(itemRequest.result);
+            };
+        });
+    }
+}

package/core/IndexedDBV4/IndexedDB_Database.d.ts

@@ -0,0 +1,20 @@
+import { AsyncVoidFunction, Logger } from '@nu-art/ts-common';
+import { DBConfigV3 } from './types.js';
+export declare class IndexedDB_Database extends Logger {
+    private dbName;
+    private db;
+    private openPromise?;
+    private registeredStores;
+    constructor(dbName: string);
+    clearDB: () => Promise<void>;
+    registerStore: (dbConfig: DBConfigV3<any>, onDBOpenCallback?: AsyncVoidFunction) => void;
+    getStore(config: DBConfigV3<any>, write?: boolean, _store?: IDBObjectStore): Promise<IDBObjectStore>;
+    storeExists: (storeName: string) => Promise<boolean>;
+    open(): Promise<IndexedDB_Database | undefined>;
+    private open_Impl;
+    private onDBOpen;
+    private getCurrentVersionData;
+    private setCurrentVersionData;
+    private generateVersionHash;
+    private getNextVersionData;
+}