dexie 4.1.0-alpha.3 → 4.1.0-alpha.5

package/dist/dexie.d.ts

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.1.0-alpha.3, Fri Oct 11 2024
+ * Version 4.1.0-alpha.5, Sun Oct 13 2024
  *
  * https://dexie.org
  *
@@ -746,7 +746,7 @@ export interface DBCoreMutateResponse {
 		[operationNumber: number]: Error;
 	};
 	lastResult: any;
-	results?: any[]; // Present on AddRequest and PutRequest.
+	results?: any[]; // Always present on responses to AddRequest and PutRequest.
 }
 export interface DBCoreAddRequest {
 	type: "add";

package/dist/dexie.js

@@ -4,7 +4,7 @@
  *
  * By David Fahlander, david.fahlander@gmail.com
  *
- * Version 4.1.0-alpha.3, Fri Oct 11 2024
+ * Version 4.1.0-alpha.5, Sun Oct 13 2024
  *
  * https://dexie.org
  *
@@ -1177,7 +1177,7 @@
         }
     }
 
-    var DEXIE_VERSION = '4.1.0-alpha.3';
+    var DEXIE_VERSION = '4.1.0-alpha.5';
     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>.";
@@ -1339,6 +1339,9 @@
         var pkKeyPath = table.schema.primKey.keyPath;
         var docCache = getDocCache(db);
         return {
+            set: function () {
+                throw new TypeError("Y.Doc properties are read-only");
+            },
             get: function () {
                 var id = getByKeyPath(this, pkKeyPath);
                 var doc = docCache.find(table.name, id, prop);
@@ -1535,13 +1538,14 @@
             }
             if (this.schema.yProps) {
                 var Y_1 = getYLibrary(db);
-                constructor =  (function (_super) {
-                    __extends(class_2, _super);
-                    function class_2() {
+                var DBObjectWithYProps =  (function (_super) {
+                    __extends(DBObjectWithYProps, _super);
+                    function DBObjectWithYProps() {
                         return _super !== null && _super.apply(this, arguments) || this;
                     }
-                    return class_2;
+                    return DBObjectWithYProps;
                 }(constructor));
+                constructor = DBObjectWithYProps;
                 this.schema.yProps.forEach(function (_a) {
                     var prop = _a.prop, updatesTable = _a.updatesTable;
                     Object.defineProperty(constructor.prototype, prop, createYDocProperty(db, Y_1, _this, prop, updatesTable));
@@ -3847,6 +3851,87 @@
         });
     }
 
+    var EMPTY_ARRAY = [];
+    function createYjsMiddleware(dbSchema, Y) {
+        return {
+            stack: 'dbcore',
+            name: 'yjsMiddleware',
+            level: 50,
+            create: function (downCore) {
+                return (__assign(__assign({}, downCore), { table: function (tableName) {
+                        var downTable = downCore.table(tableName);
+                        var dbTableSchema = dbSchema[tableName];
+                        var yProps = dbTableSchema.yProps;
+                        if (!yProps || yProps.length === 0)
+                            return downTable;
+                        var tableMiddleware = __assign(__assign({}, downTable), { mutate: function (req) {
+                                if (req.type !== 'add' && req.type !== 'put')
+                                    return downTable.mutate(req);
+                                var reqClone = req;
+                                var updateSources = yProps
+                                    .map(function (p) { return ({
+                                    p: p,
+                                    entries: req.values.flatMap(function (value, iter) {
+                                        if (!value || typeof value !== 'object')
+                                            throw new TypeError("Table ".concat(tableName, " (with Y-properties) must only contain objects"));
+                                        if (!hasOwn(value, p.prop))
+                                            return [];
+                                        if (reqClone === req)
+                                            reqClone = __assign(__assign({}, req), { values: req.values.map(function (v) { return (__assign({}, v)); }) });
+                                        delete reqClone.values[iter][p.prop];
+                                        var doc = value[p.prop];
+                                        if (doc === null)
+                                            throw new TypeError("Cannot set Y property to null");
+                                        if (doc === undefined)
+                                            return EMPTY_ARRAY;
+                                        if (typeof doc !== 'object' || !('whenLoaded' in doc)) {
+                                            throw new TypeError("Y properties can only be inited with an Y.Doc instance or undefined to create an empty Y.Doc");
+                                        }
+                                        if (req.type === 'put')
+                                            throw new TypeError("Setting ".concat(tableName, ".").concat(p.prop, " (declared as ").concat(p.prop, ":Y) is only allowed when inserting new objects using db.").concat(tableName, ".add(), not put() or update()."));
+                                        if (Y.encodeStateVector(doc).length === 1) {
+                                            return EMPTY_ARRAY;
+                                        }
+                                        return {
+                                            iter: iter,
+                                            u: Y.encodeStateAsUpdateV2(doc),
+                                        };
+                                    }),
+                                }); })
+                                    .filter(function (_a) {
+                                    var entries = _a.entries;
+                                    return entries.length > 0;
+                                });
+                                if (req === reqClone)
+                                    return downTable.mutate(req);
+                                return downTable.mutate(reqClone).then(function (res) {
+                                    if (updateSources.length === 0)
+                                        return res;
+                                    return Promise.all(updateSources.map(function (_a) {
+                                        var p = _a.p, entries = _a.entries;
+                                        var updatesTable = downCore.table(p.updatesTable);
+                                        var updatesToInsert = entries.map(function (_a) {
+                                            var iter = _a.iter, u = _a.u;
+                                            return ({
+                                                k: res.results[iter],
+                                                u: u,
+                                                f: 1,
+                                            });
+                                        });
+                                        return updatesTable.mutate({
+                                            type: 'add',
+                                            values: updatesToInsert,
+                                            trans: req.trans,
+                                        });
+                                    })).then(function () { return res; });
+                                });
+                            } });
+                        return tableMiddleware;
+                    } }));
+            },
+        };
+    }
+
     var Version =  (function () {
         function Version() {
         }
@@ -3911,6 +3996,12 @@
                     db.table(tableName).mapToClass(dbschema[tableName].mappedClass || Object);
                 }
             });
+            if (Object.values(dbschema).some(function (table) { return table.yProps; })) {
+                db.use(createYjsMiddleware(dbschema, getYLibrary(db)));
+            }
+            else {
+                db.unuse({ stack: 'dbcore', name: 'yjsMiddleware' });
+            }
             return this;
         };
         Version.prototype.upgrade = function (upgradeFunction) {
@@ -5664,7 +5755,10 @@
                 return p.then(function () {
                     return db.transaction('rw', updTbl, function () {
                         return updTbl.get(0).then(function (current) {
-                            return updTbl.put(__assign(__assign({}, current), { lastCompressed: Math.max(lastUpdateToCompress, (current === null || current === void 0 ? void 0 : current.lastCompressed) || 0) }));
+                            if (current && lastUpdateToCompress <= current.lastCompressed) {
+                                return;
+                            }
+                            return updTbl.put(__assign(__assign({}, current), { lastCompressed: lastUpdateToCompress }));
                         });
                     });
                 });
@@ -5696,7 +5790,8 @@
         });
     }
 
-    var INTERVAL = 10000;
+    var GC_DELAY = 10000;
+    var GC_INTERVAL = 300000;
     function periodicGC(db) {
         var timer = null;
         db.on('ready', function (db) {
@@ -5704,13 +5799,15 @@
                 var gc_1 = function () {
                     if (!db.isOpen())
                         return;
-                    compressYDocs(db, INTERVAL).catch(function (err) {
+                    compressYDocs(db, GC_INTERVAL).catch(function (err) {
+                        if (err && err.name === 'DatabaseClosedError')
+                            return;
                         console.debug('Error during periodic GC', err);
                     }).then(function () {
-                        timer = setTimeout(gc_1, INTERVAL);
+                        timer = setTimeout(gc_1, GC_INTERVAL);
                     });
                 };
-                timer = setTimeout(gc_1, INTERVAL);
+                timer = setTimeout(gc_1, GC_DELAY);
             }
         }, true);
         db.on('close', function () {