@bbn/bbn 2.0.221 → 2.0.222

package/dist/com.js

@@ -53,7 +53,6 @@ const fetchRequest = (method, url, config = {}, aborter) => {
     const hasBody = methodsWithBody.includes(method.toUpperCase());
     if (config.data != null && hasBody) {
         // You can get fancier here (JSON, FormData, etc.)
-        bbn.fn.log('DATA', config.data);
         if (typeof config.data === 'object' && !(config.data instanceof FormData)) {
             fetchConfig.headers.set('Content-Type', 'application/json');
             fetchConfig.body = JSON.stringify(config.data);

package/dist/db.d.ts

@@ -16,6 +16,7 @@ type WhereObject = Record<string, unknown> | null;
 type OrderClause = unknown;
 interface IDbApi {
     lastError(): unknown;
+    close(): void;
     insert(table: string, data: Record<string, unknown> | Record<string, unknown>[]): Promise<number>;
     update(table: string, data: Record<string, unknown>, where: WhereObject, replace?: boolean): Promise<number>;
     delete(table: string, where: Record<string, unknown>): Promise<number>;
@@ -32,7 +33,8 @@ interface DbManager {
     _stores: Record<string, unknown>;
     ok: boolean;
     open(name: string): Promise<IDbApi>;
-    add(database: string, name: string, structure: DbStructure): Promise<void>;
+    add(database: string, name: string, structure: DbStructure): Promise<IDBDatabase>;
+    openRaw(name: string, version?: number): Promise<IDBDatabase>;
     remove(database: string, name: string): Promise<void>;
     updateStructure(storeName: string, structure: DbStructure, database: IDBDatabase): void;
     reopenWithUpgrade(name: string): Promise<IDBDatabase>;

package/dist/db.js

@@ -82,12 +82,22 @@ class DbObject {
         this.lastErr = null;
         this.dbName = dbName;
     }
-    get connection() {
-        const conn = db._connections[this.dbName];
-        if (!conn) {
-            throw new Error(_('The database %s is not open', this.dbName));
-        }
-        return conn;
+    hasMissingStores(database, conn) {
+        const structures = db._structures[database] || {};
+        return Object.keys(structures).some(storeName => !conn.objectStoreNames.contains(storeName));
+    }
+    getConnection() {
+        return __awaiter(this, arguments, void 0, function* (database = '') {
+            let conn = db._connections[database || this.dbName];
+            if (!conn) {
+                const tmp = yield db.open(database || this.dbName);
+                if (!db._connections[database || this.dbName]) {
+                    throw new Error(_('The database %s is not open', this.dbName));
+                }
+                conn = db._connections[database || this.dbName];
+            }
+            return conn;
+        });
     }
     get structure() {
         const structure = db._structures[this.dbName];
@@ -97,27 +107,43 @@ class DbObject {
         return structure;
     }
     getStore(table, mode) {
-        const tx = this.connection.transaction([table], mode);
-        tx.onabort = () => {
-            this.lastErr = tx.error;
-            log(tx.error);
-        };
-        tx.onerror = () => {
-            this.lastErr = tx.error;
-            log(tx.error);
-        };
-        return [tx, tx.objectStore(table)];
+        return __awaiter(this, void 0, void 0, function* () {
+            const connection = yield this.getConnection();
+            if (!this.structure[table]) {
+                throw new Error(_('Table %s is not defined in database structure %s', table, this.dbName));
+            }
+            if (!connection.objectStoreNames.contains(table)) {
+                throw new Error(_('Table %s does not exist in database %s. Schema upgrade required.', table, this.dbName));
+            }
+            const tx = connection.transaction([table], mode);
+            tx.onabort = () => {
+                this.lastErr = tx.error;
+                log(tx.error);
+            };
+            tx.onerror = () => {
+                this.lastErr = tx.error;
+                log(tx.error);
+            };
+            return [tx, tx.objectStore(table)];
+        });
     }
     lastError() {
         return this.lastErr;
     }
+    close() {
+        const conn = db._connections[this.dbName];
+        if (conn) {
+            conn.close();
+            delete db._connections[this.dbName];
+        }
+    }
     insert(table, data) {
         return __awaiter(this, void 0, void 0, function* () {
             const rows = Array.isArray(data) ? data : [data];
             if (!rows.length) {
                 return 0;
             }
-            const [tx, store] = this.getStore(table, 'readwrite');
+            const [tx, store] = yield this.getStore(table, 'readwrite');
             let inserted = 0;
             for (const row of rows) {
                 const req = store.put(row);
@@ -144,7 +170,7 @@ class DbObject {
             if (Array.isArray(primary)) {
                 throw new Error(_('Composite primary keys are not supported by this update implementation'));
             }
-            const [tx, store] = this.getStore(table, 'readwrite');
+            const [tx, store] = yield this.getStore(table, 'readwrite');
             let updated = 0;
             for (const row of rows) {
                 const nextRow = extend({}, replace ? { [primary]: row[primary] } : row, data);
@@ -174,7 +200,7 @@ class DbObject {
             if (!(primary in where)) {
                 throw new Error(_('No primary key in the filter'));
             }
-            const [tx, store] = this.getStore(table, 'readwrite');
+            const [tx, store] = yield this.getStore(table, 'readwrite');
             store.delete(where[primary]);
             yield transactionDone(tx);
             return 1;
@@ -196,7 +222,7 @@ class DbObject {
     selectAll(table_1) {
         return __awaiter(this, arguments, void 0, function* (table, fields = [], where = null, order = null, start = 0, limit = null) {
             void order;
-            const [tx, store] = this.getStore(table, 'readonly');
+            const [tx, store] = yield this.getStore(table, 'readonly');
             const structure = this.structure[table];
             const primary = getPrimaryKey(structure);
             const results = [];
@@ -241,7 +267,7 @@ class DbObject {
                     }
                     const matches = !where || !((_b = (_a = globalThis.bbn) === null || _a === void 0 ? void 0 : _a.fn) === null || _b === void 0 ? void 0 : _b.search)
                         ? true
-                        : !globalThis.bbn.fn.search([cursor.value], where);
+                        : 0 === globalThis.bbn.fn.search([cursor.value], where);
                     if (matches) {
                         if (i >= start) {
                             const transformed = transformResult(cursor.value, fields);
@@ -277,11 +303,15 @@ class DbObject {
     }
     copyTable(target_1, table_1) {
         return __awaiter(this, arguments, void 0, function* (target, table, fields = [], where = null, order = null, start = 0, limit = null) {
-            if (!this.connection.objectStoreNames.contains(target)) {
+            if (!this.structure[table]) {
+                throw new Error(_('Source table %s does not exist in structure', table));
+            }
+            let connection = yield this.getConnection();
+            if (!connection.objectStoreNames.contains(target)) {
                 yield db.add(this.dbName, target, this.structure[table]);
-                yield db.open(this.dbName);
+                connection = yield this.getConnection();
             }
-            if (!this.connection.objectStoreNames.contains(target)) {
+            if (!connection.objectStoreNames.contains(target)) {
                 throw new Error(_('The target table %s does not exist', target));
             }
             const rows = yield this.selectAll(table, fields, where, order, start, limit);
@@ -348,8 +378,12 @@ const db = {
     },
     reopenWithUpgrade(name) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this._structures[name]) {
+                throw new Error(_('Impossible to find a structure for the database %s', name));
+            }
             const existingVersion = yield this.getExistingVersion(name);
             const nextVersion = existingVersion + 1;
+            log(_('Going from version %s to version %s for database %s', existingVersion, nextVersion, name));
             if (this._connections[name]) {
                 this._connections[name].close();
                 delete this._connections[name];
@@ -374,7 +408,10 @@ const db = {
                     resolve(req.result);
                 };
                 req.onerror = () => reject(req.error);
-                req.onblocked = () => reject(req.error || new Error(_('IndexedDB upgrade blocked')));
+                req.onblocked = (event) => {
+                    log(event);
+                    reject(_('reopenWithUpgrade: Upgrade blocked for database %s. Please close other connections to proceed.', name));
+                };
             });
         });
     },
@@ -405,6 +442,9 @@ const db = {
                     resolve(req.result);
                 };
                 req.onerror = () => reject(req.error);
+                req.onblocked = (event) => {
+                    reject(_('open: Upgrade blocked for database %s. Please close other connections to proceed.', database));
+                };
             });
             return new DbObject(database);
         });
@@ -412,6 +452,7 @@ const db = {
     add(database, name, structure) {
         return __awaiter(this, void 0, void 0, function* () {
             var _a;
+            log(_('Adding database structure for %s.%s', database, name));
             if (!((_a = structure === null || structure === void 0 ? void 0 : structure.keys) === null || _a === void 0 ? void 0 : _a.PRIMARY) || !(structure === null || structure === void 0 ? void 0 : structure.fields)) {
                 throw new Error(_('The database structure for %s is not valid (missing keys, fields, or primary key)', name));
             }
@@ -419,42 +460,82 @@ const db = {
                 this._structures[database] = {};
             }
             this._structures[database][name] = structure;
-            // Only upgrade if the DB already exists/open and the store is missing
             const conn = this._connections[database];
-            if (conn && !conn.objectStoreNames.contains(name)) {
-                yield this.reopenWithUpgrade(database);
+            if (conn) {
+                if (!conn.objectStoreNames.contains(name)) {
+                    return yield this.reopenWithUpgrade(database);
+                }
+                return conn;
+            }
+            // No live connection: inspect current DB and upgrade if needed.
+            const existingVersion = yield this.getExistingVersion(database);
+            const hasDbAlready = existingVersion > 0;
+            if (!hasDbAlready) {
+                yield this.open(database);
+                return this._connections[database];
+            }
+            // DB exists already: open temporarily and check if store exists
+            const tmp = yield this.openRaw(database);
+            const hasStore = tmp.objectStoreNames.contains(name);
+            tmp.close();
+            if (!hasStore) {
+                return yield this.reopenWithUpgrade(database);
+            }
+            return yield this.openRaw(database);
+        });
+    },
+    openRaw(name, version) {
+        return new Promise((resolve, reject) => {
+            if (!idb) {
+                reject(new Error(_('IndexedDB is not available')));
+                return;
             }
+            const req = version ? idb.open(name, version) : idb.open(name);
+            req.onsuccess = () => resolve(req.result);
+            req.onerror = () => reject(req.error);
+            req.onblocked = () => reject(new Error(_('IndexedDB open blocked for database %s', name)));
         });
     },
     remove(database, name) {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            (_a = this._structures[database]) === null || _a === void 0 ? true : delete _a[name];
-            const conn = this._connections[database];
-            if (!conn) {
+            const currentStructure = this._structures[database];
+            if (!(currentStructure === null || currentStructure === void 0 ? void 0 : currentStructure[name])) {
                 return;
             }
-            const nextVersion = conn.version + 1;
-            conn.close();
-            delete this._connections[database];
-            yield new Promise((resolve, reject) => {
-                if (!idb) {
-                    reject(new Error(_('IndexedDB is not available')));
+            const old = currentStructure[name];
+            delete currentStructure[name];
+            try {
+                const conn = this._connections[database];
+                if (!conn) {
                     return;
                 }
-                const req = idb.open(database, nextVersion);
-                req.onupgradeneeded = () => {
-                    const dbInstance = req.result;
-                    if (dbInstance.objectStoreNames.contains(name)) {
-                        dbInstance.deleteObjectStore(name);
+                const nextVersion = conn.version + 1;
+                conn.close();
+                delete this._connections[database];
+                yield new Promise((resolve, reject) => {
+                    if (!idb) {
+                        reject(new Error(_('IndexedDB is not available')));
+                        return;
                     }
-                };
-                req.onsuccess = () => {
-                    this._connections[database] = req.result;
-                    resolve();
-                };
-                req.onerror = () => reject(req.error);
-            });
+                    const req = idb.open(database, nextVersion);
+                    req.onupgradeneeded = () => {
+                        const dbInstance = req.result;
+                        if (dbInstance.objectStoreNames.contains(name)) {
+                            dbInstance.deleteObjectStore(name);
+                        }
+                    };
+                    req.onsuccess = () => {
+                        this._connections[database] = req.result;
+                        resolve();
+                    };
+                    req.onerror = () => reject(req.error);
+                    req.onblocked = () => reject(new Error(_('Remove blocked for database %s', database)));
+                });
+            }
+            catch (e) {
+                currentStructure[name] = old;
+                throw e;
+            }
         });
     }
 };

package/dist/fn/init.js

@@ -81,7 +81,7 @@ export default function init(cfg, force) {
             if (bbn.var.colors) {
                 addColors(bbn.var.colors);
             }
-            globalThis.document.addEventListener("visibilitychange", () => {
+            document.addEventListener("visibilitychange", () => {
                 if (document.hidden) {
                     bbn.env.isVisible = false;
                 }
@@ -89,7 +89,7 @@ export default function init(cfg, force) {
                     bbn.env.isVisible = true;
                 }
             });
-            globalThis.document.addEventListener("focus", (e) => {
+            document.addEventListener("focus", (e) => {
                 if (e.target instanceof HTMLElement &&
                     !e.target.classList.contains("bbn-no")) {
                     bbn.env.focused = e.target;
@@ -97,7 +97,7 @@ export default function init(cfg, force) {
                 bbn.env.isFocused = true;
                 bbn.env.last_focus = timestamp();
             });
-            globalThis.document.addEventListener("blur", (e) => {
+            document.addEventListener("blur", (e) => {
                 if (e.target instanceof HTMLElement &&
                     !e.target.classList.contains("bbn-no")) {
                     bbn.env.focused = e.target;
@@ -105,29 +105,29 @@ export default function init(cfg, force) {
                 bbn.env.isFocused = false;
                 bbn.env.last_focus = timestamp();
             });
-            globalThis.document.addEventListener("click", onActivity);
-            globalThis.document.addEventListener("keydown", onActivity);
-            globalThis.document.addEventListener("focusin", onFocus);
-            globalThis.document.addEventListener("focusout", onFocus);
-            globalThis.addEventListener("hashchange", () => {
+            document.addEventListener("click", onActivity);
+            document.addEventListener("keydown", onActivity);
+            document.addEventListener("focusin", onFocus);
+            document.addEventListener("focusout", onFocus);
+            window.addEventListener("hashchange", () => {
                 bbn.env.hashChanged = new Date().getTime();
             }, false);
-            globalThis.addEventListener("resize", () => {
+            window.addEventListener("resize", () => {
                 resize();
             });
-            globalThis.addEventListener("orientationchange", () => {
+            window.addEventListener("orientationchange", () => {
                 resize();
             });
             resize();
             if (isMobile()) {
-                globalThis.document.body.classList.add("bbn-mobile");
+                document.body.classList.add("bbn-mobile");
                 if (isTabletDevice()) {
-                    globalThis.document.body.classList.add("bbn-tablet");
+                    document.body.classList.add("bbn-tablet");
                 }
             }
-            if (globalThis.history) {
-                globalThis.onpopstate = function (e) {
-                    let h = globalThis.history;
+            if (window.history) {
+                window.onpopstate = function (e) {
+                    let h = window.history;
                     if (!bbn.env.historyDisabled && h) {
                         //e.preventDefault();
                         if (bbn.fn.defaultHistoryFunction(h.state)) {
@@ -143,17 +143,17 @@ export default function init(cfg, force) {
                     }
                 };
             }
-            globalThis.addEventListener('online', () => {
+            window.addEventListener('online', () => {
                 bbn.env.online = true;
             });
-            globalThis.addEventListener('offline', () => {
+            window.addEventListener('offline', () => {
                 bbn.env.online = false;
             });
             bbn.env.isInit = true;
-            globalThis.document.dispatchEvent(new Event("bbninit"));
-            if (bbn.env.logging) {
-                log("Logging in bbn is enabled");
-            }
+            document.dispatchEvent(new Event("bbninit"));
+        }
+        if (bbn.env.logging) {
+            log("Logging in bbn is enabled");
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bbn/bbn",
-  "version": "2.0.221",
+  "version": "2.0.222",
   "description": "Javascript toolkit",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",