dexie 4.0.1-beta.7 → 4.0.1-beta.8

package/dist/dexie.d.ts

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.1-beta.7, Wed Jan 31 2024
+ * Version 4.0.1-beta.8, Wed Feb 07 2024
  *
  * https://dexie.org
  *

package/dist/dexie.js

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.0.1-beta.7, Wed Jan 31 2024
+ * Version 4.0.1-beta.8, Wed Feb 07 2024
  *
  * https://dexie.org
  *
@@ -232,7 +232,7 @@
     function flatten(a) {
         return concat.apply([], a);
     }
-    var intrinsicTypeNames = "Array,Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,FileSystemDirectoryHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey"
+    var intrinsicTypeNames = "BigUint64Array,BigInt64Array,Array,Boolean,String,Date,RegExp,Blob,File,FileList,FileSystemFileHandle,FileSystemDirectoryHandle,ArrayBuffer,DataView,Uint8ClampedArray,ImageBitmap,ImageData,Map,Set,CryptoKey"
         .split(',').concat(flatten([8, 16, 32, 64].map(function (num) { return ["Int", "Uint", "Float"].map(function (t) { return t + num + "Array"; }); }))).filter(function (t) { return _global[t]; });
     var intrinsicTypes = new Set(intrinsicTypeNames.map(function (t) { return _global[t]; }));
     function cloneSimpleObjectTree(o) {
@@ -1235,7 +1235,7 @@
                 return rejection(new exceptions.DatabaseClosed(db._state.dbOpenError));
             }
             if (!db._state.isBeingOpened) {
-                if (!db._options.autoOpen)
+                if (!db._state.autoOpen)
                     return rejection(new exceptions.DatabaseClosed());
                 db.open().catch(nop);
             }
@@ -1271,7 +1271,7 @@
         }
     }
 
-    var DEXIE_VERSION = '4.0.1-beta.7';
+    var DEXIE_VERSION = '4.0.1-beta.8';
     var maxString = String.fromCharCode(65535);
     var minKey = -Infinity;
     var INVALID_KEY_ARGUMENT = "Invalid key provided. Keys must be of type string, number, Date or Array<string | number | Date>.";
@@ -3410,6 +3410,10 @@
     }
     function runUpgraders(db, oldVersion, idbUpgradeTrans, reject) {
         var globalSchema = db._dbSchema;
+        if (idbUpgradeTrans.objectStoreNames.contains('$meta') && !globalSchema.$meta) {
+            globalSchema.$meta = createTableSchema("$meta", parseIndexSyntax("")[0], []);
+            db._storeNames.push('$meta');
+        }
         var trans = db._createTransaction('readwrite', db._storeNames, globalSchema);
         trans.create(idbUpgradeTrans);
         trans._completion.catch(reject);
@@ -3425,16 +3429,60 @@
                 generateMiddlewareStacks(db, idbUpgradeTrans);
                 DexiePromise.follow(function () { return db.on.populate.fire(trans); }).catch(rejectTransaction);
             }
-            else
-                updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans).catch(rejectTransaction);
+            else {
+                generateMiddlewareStacks(db, idbUpgradeTrans);
+                return getExistingVersion(db, trans, oldVersion)
+                    .then(function (oldVersion) { return updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans); })
+                    .catch(rejectTransaction);
+            }
         });
     }
+    function patchCurrentVersion(db, idbUpgradeTrans) {
+        createMissingTables(db._dbSchema, idbUpgradeTrans);
+        if (idbUpgradeTrans.db.version % 10 === 0 && !idbUpgradeTrans.objectStoreNames.contains('$meta')) {
+            idbUpgradeTrans.db.createObjectStore('$meta').add(Math.ceil((idbUpgradeTrans.db.version / 10) - 1), 'version');
+        }
+        var globalSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
+        adjustToExistingIndexNames(db, db._dbSchema, idbUpgradeTrans);
+        var diff = getSchemaDiff(globalSchema, db._dbSchema);
+        var _loop_1 = function (tableChange) {
+            if (tableChange.change.length || tableChange.recreate) {
+                console.warn("Unable to patch indexes of table ".concat(tableChange.name, " because it has changes on the type of index or primary key."));
+                return { value: void 0 };
+            }
+            var store = idbUpgradeTrans.objectStore(tableChange.name);
+            tableChange.add.forEach(function (idx) {
+                if (debug)
+                    console.debug("Dexie upgrade patch: Creating missing index ".concat(tableChange.name, ".").concat(idx.src));
+                addIndex(store, idx);
+            });
+        };
+        for (var _i = 0, _a = diff.change; _i < _a.length; _i++) {
+            var tableChange = _a[_i];
+            var state_1 = _loop_1(tableChange);
+            if (typeof state_1 === "object")
+                return state_1.value;
+        }
+    }
+    function getExistingVersion(db, trans, oldVersion) {
+        if (trans.storeNames.includes('$meta')) {
+            return trans.table('$meta').get('version').then(function (metaVersion) {
+                return metaVersion != null ? metaVersion : oldVersion;
+            });
+        }
+        else {
+            return DexiePromise.resolve(oldVersion);
+        }
+    }
     function updateTablesAndIndexes(db, oldVersion, trans, idbUpgradeTrans) {
         var queue = [];
         var versions = db._versions;
         var globalSchema = db._dbSchema = buildGlobalSchema(db, db.idbdb, idbUpgradeTrans);
         var anyContentUpgraderHasRun = false;
         var versToRun = versions.filter(function (v) { return v._cfg.version >= oldVersion; });
+        if (versToRun.length === 0) {
+            return DexiePromise.resolve();
+        }
         versToRun.forEach(function (version) {
             queue.push(function () {
                 var oldSchema = globalSchema;
@@ -3499,6 +3547,18 @@
                 setApiOnPlace(db, [db.Transaction.prototype], db._storeNames, db._dbSchema);
                 trans.schema = db._dbSchema;
             });
+            queue.push(function (idbtrans) {
+                if (db.idbdb.objectStoreNames.contains('$meta')) {
+                    if (Math.ceil(db.idbdb.version / 10) === version._cfg.version) {
+                        db.idbdb.deleteObjectStore('$meta');
+                        delete db._dbSchema.$meta;
+                        db._storeNames = db._storeNames.filter(function (name) { return name !== '$meta'; });
+                    }
+                    else {
+                        idbtrans.objectStore('$meta').put(version._cfg.version, 'version');
+                    }
+                }
+            });
         });
         function runQueue() {
             return queue.length ? DexiePromise.resolve(queue.shift()(trans.idbtrans)).then(runQueue) :
@@ -3573,6 +3633,8 @@
     function createMissingTables(newSchema, idbtrans) {
         keys(newSchema).forEach(function (tableName) {
             if (!idbtrans.db.objectStoreNames.contains(tableName)) {
+                if (debug)
+                    console.debug('Dexie: Creating missing table', tableName);
                 createTable(idbtrans, tableName, newSchema[tableName].primKey, newSchema[tableName].indexes);
             }
         });
@@ -4020,6 +4082,8 @@
         state.dbOpenError = null;
         state.openComplete = false;
         var openCanceller = state.openCanceller;
+        var nativeVerToOpen = Math.round(db.verno * 10);
+        var schemaPatchMode = false;
         function throwIfCancelled() {
             if (state.openCanceller !== openCanceller)
                 throw new exceptions.DatabaseClosed('db.open() was cancelled');
@@ -4031,9 +4095,9 @@
             if (!indexedDB)
                 throw new exceptions.MissingAPI();
             var dbName = db.name;
-            var req = state.autoSchema ?
+            var req = state.autoSchema || !nativeVerToOpen ?
                 indexedDB.open(dbName) :
-                indexedDB.open(dbName, Math.round(db.verno * 10));
+                indexedDB.open(dbName, nativeVerToOpen);
             if (!req)
                 throw new exceptions.MissingAPI();
             req.onerror = eventRejectHandler(reject);
@@ -4054,6 +4118,9 @@
                     var oldVer = e.oldVersion > Math.pow(2, 62) ? 0 : e.oldVersion;
                     wasCreated = oldVer < 1;
                     db.idbdb = req.result;
+                    if (schemaPatchMode) {
+                        patchCurrentVersion(db, upgradeTransaction);
+                    }
                     runUpgraders(db, oldVer / 10, upgradeTransaction, reject);
                 }
             }, reject);
@@ -4068,8 +4135,12 @@
                             readGlobalSchema(db, idbdb, tmpTrans);
                         else {
                             adjustToExistingIndexNames(db, db._dbSchema, tmpTrans);
-                            if (!verifyInstalledSchema(db, tmpTrans)) {
-                                console.warn("Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Some queries may fail.");
+                            if (!verifyInstalledSchema(db, tmpTrans) && !schemaPatchMode) {
+                                console.warn("Dexie SchemaDiff: Schema was extended without increasing the number passed to db.version(). Dexie will add missing parts and increment native version number to workaround this.");
+                                idbdb.close();
+                                nativeVerToOpen = idbdb.version + 1;
+                                schemaPatchMode = true;
+                                return resolve(tryOpenDB());
                             }
                         }
                         generateMiddlewareStacks(db, tmpTrans);
@@ -4089,14 +4160,22 @@
                 resolve();
             }, reject);
         }).catch(function (err) {
-            if (err && err.name === 'UnknownError' && state.PR1398_maxLoop > 0) {
-                state.PR1398_maxLoop--;
-                console.warn('Dexie: Workaround for Chrome UnknownError on open()');
-                return tryOpenDB();
-            }
-            else {
-                return DexiePromise.reject(err);
+            switch (err === null || err === void 0 ? void 0 : err.name) {
+                case "UnknownError":
+                    if (state.PR1398_maxLoop > 0) {
+                        state.PR1398_maxLoop--;
+                        console.warn('Dexie: Workaround for Chrome UnknownError on open()');
+                        return tryOpenDB();
+                    }
+                    break;
+                case "VersionError":
+                    if (nativeVerToOpen > 0) {
+                        nativeVerToOpen = 0;
+                        return tryOpenDB();
+                    }
+                    break;
             }
+            return DexiePromise.reject(err);
         }); };
         return DexiePromise.race([
             openCanceller,
@@ -5212,7 +5291,8 @@
                 cancelOpen: nop,
                 openCanceller: null,
                 autoSchema: true,
-                PR1398_maxLoop: 3
+                PR1398_maxLoop: 3,
+                autoOpen: options.autoOpen,
             };
             state.dbReadyPromise = new DexiePromise(function (resolve) {
                 state.dbReadyResolve = resolve;
@@ -5329,7 +5409,7 @@
                     return reject(new exceptions.DatabaseClosed(_this._state.dbOpenError));
                 }
                 if (!_this._state.isBeingOpened) {
-                    if (!_this._options.autoOpen) {
+                    if (!_this._state.autoOpen) {
                         reject(new exceptions.DatabaseClosed());
                         return;
                     }
@@ -5384,10 +5464,14 @@
         };
         Dexie.prototype.close = function (_a) {
             var _b = _a === void 0 ? { disableAutoOpen: true } : _a, disableAutoOpen = _b.disableAutoOpen;
+            var wasOpen = this.isOpen();
             this._close();
             var state = this._state;
             if (disableAutoOpen)
-                this._options.autoOpen = false;
+                this._state.autoOpen = false;
+            else if (wasOpen && this._options.autoOpen) {
+                this._state.autoOpen = true;
+            }
             state.dbOpenError = new exceptions.DatabaseClosed();
             if (state.isBeingOpened)
                 state.cancelOpen(state.dbOpenError);