dexie-cloud-addon 4.0.0-beta.16 → 4.0.0-beta.17

package/dist/umd/service-worker.js

@@ -4649,107 +4649,10 @@
         };
     }
 
-    const SECONDS = 1000;
-    const MINUTES = 60 * SECONDS;
-
-    const myId = randomString$1(16);
-
-    const GUARDED_JOB_HEARTBEAT = 1 * SECONDS;
-    const GUARDED_JOB_TIMEOUT = 1 * MINUTES;
-    async function performGuardedJob(db, jobName, jobsTableName, job, { awaitRemoteJob } = {}) {
-        // Start working.
-        //
-        // Check if someone else is working on this already.
-        //
-        const jobsTable = db.table(jobsTableName);
-        async function aquireLock() {
-            const gotTheLock = await db.transaction('rw!', jobsTableName, async () => {
-                const currentWork = await jobsTable.get(jobName);
-                if (!currentWork) {
-                    // No one else is working. Let's record that we are.
-                    await jobsTable.add({
-                        nodeId: myId,
-                        started: new Date(),
-                        heartbeat: new Date()
-                    }, jobName);
-                    return true;
-                }
-                else if (currentWork.heartbeat.getTime() <
-                    Date.now() - GUARDED_JOB_TIMEOUT) {
-                    console.warn(`Latest ${jobName} worker seem to have died.\n`, `The dead job started:`, currentWork.started, `\n`, `Last heart beat was:`, currentWork.heartbeat, '\n', `We're now taking over!`);
-                    // Now, take over!
-                    await jobsTable.put({
-                        nodeId: myId,
-                        started: new Date(),
-                        heartbeat: new Date()
-                    }, jobName);
-                    return true;
-                }
-                return false;
-            });
-            if (gotTheLock)
-                return true;
-            // Someone else took the job.
-            if (awaitRemoteJob) {
-                try {
-                    const jobDoneObservable = rxjs.from(Dexie.liveQuery(() => jobsTable.get(jobName))).pipe(timeout(GUARDED_JOB_TIMEOUT), filter((job) => !job)); // Wait til job is not there anymore.
-                    await jobDoneObservable.toPromise();
-                    return false;
-                }
-                catch (err) {
-                    if (err.name !== 'TimeoutError') {
-                        throw err;
-                    }
-                    // Timeout stopped us! Try aquire the lock now.
-                    // It will likely succeed this time unless
-                    // another client took it.
-                    return await aquireLock();
-                }
-            }
-            return false;
-        }
-        if (await aquireLock()) {
-            // We own the lock entry and can do our job undisturbed.
-            // We're not within a transaction, but these type of locks
-            // spans over transactions.
-            // Start our heart beat during the job.
-            // Use setInterval to make sure we are updating heartbeat even during long-lived fetch calls.
-            const heartbeat = setInterval(() => {
-                jobsTable.update(jobName, (job) => {
-                    if (job.nodeId === myId) {
-                        job.heartbeat = new Date();
-                    }
-                });
-            }, GUARDED_JOB_HEARTBEAT);
-            try {
-                return await job();
-            }
-            finally {
-                // Stop heartbeat
-                clearInterval(heartbeat);
-                // Remove the persisted job state:
-                await db.transaction('rw!', jobsTableName, async () => {
-                    const currentWork = await jobsTable.get(jobName);
-                    if (currentWork && currentWork.nodeId === myId) {
-                        jobsTable.delete(jobName);
-                    }
-                });
-            }
-        }
-    }
-
     async function performInitialSync(db, cloudOptions, cloudSchema) {
-        console.debug("Performing initial sync");
-        await performGuardedJob(db, 'initialSync', '$jobs', async () => {
-            // Even though caller has already checked it,
-            // Do check again (now within a transaction) that we really do not have a sync state:
-            const syncState = await db.getPersistedSyncState();
-            if (!syncState?.initiallySynced) {
-                await sync(db, cloudOptions, cloudSchema, { isInitialSync: true });
-            }
-        }, { awaitRemoteJob: true } // Don't return until the job is done!
-        );
-        console.debug("Done initial sync");
+        console.debug('Performing initial sync');
+        await sync(db, cloudOptions, cloudSchema, { isInitialSync: true });
+        console.debug('Done initial sync');
     }
 
     const USER_INACTIVITY_TIMEOUT = 180000; // 3 minutes
@@ -5103,6 +5006,95 @@
             : false;
     }
 
+    const SECONDS = 1000;
+    const MINUTES = 60 * SECONDS;
+
+    const myId = randomString$1(16);
+
+    const GUARDED_JOB_HEARTBEAT = 1 * SECONDS;
+    const GUARDED_JOB_TIMEOUT = 1 * MINUTES;
+    async function performGuardedJob(db, jobName, jobsTableName, job, { awaitRemoteJob } = {}) {
+        // Start working.
+        //
+        // Check if someone else is working on this already.
+        //
+        const jobsTable = db.table(jobsTableName);
+        async function aquireLock() {
+            const gotTheLock = await db.transaction('rw!', jobsTableName, async () => {
+                const currentWork = await jobsTable.get(jobName);
+                if (!currentWork) {
+                    // No one else is working. Let's record that we are.
+                    await jobsTable.add({
+                        nodeId: myId,
+                        started: new Date(),
+                        heartbeat: new Date()
+                    }, jobName);
+                    return true;
+                }
+                else if (currentWork.heartbeat.getTime() <
+                    Date.now() - GUARDED_JOB_TIMEOUT) {
+                    console.warn(`Latest ${jobName} worker seem to have died.\n`, `The dead job started:`, currentWork.started, `\n`, `Last heart beat was:`, currentWork.heartbeat, '\n', `We're now taking over!`);
+                    // Now, take over!
+                    await jobsTable.put({
+                        nodeId: myId,
+                        started: new Date(),
+                        heartbeat: new Date()
+                    }, jobName);
+                    return true;
+                }
+                return false;
+            });
+            if (gotTheLock)
+                return true;
+            // Someone else took the job.
+            if (awaitRemoteJob) {
+                try {
+                    const jobDoneObservable = rxjs.from(Dexie.liveQuery(() => jobsTable.get(jobName))).pipe(timeout(GUARDED_JOB_TIMEOUT), filter((job) => !job)); // Wait til job is not there anymore.
+                    await jobDoneObservable.toPromise();
+                    return false;
+                }
+                catch (err) {
+                    if (err.name !== 'TimeoutError') {
+                        throw err;
+                    }
+                    // Timeout stopped us! Try aquire the lock now.
+                    // It will likely succeed this time unless
+                    // another client took it.
+                    return await aquireLock();
+                }
+            }
+            return false;
+        }
+        if (await aquireLock()) {
+            // We own the lock entry and can do our job undisturbed.
+            // We're not within a transaction, but these type of locks
+            // spans over transactions.
+            // Start our heart beat during the job.
+            // Use setInterval to make sure we are updating heartbeat even during long-lived fetch calls.
+            const heartbeat = setInterval(() => {
+                jobsTable.update(jobName, (job) => {
+                    if (job.nodeId === myId) {
+                        job.heartbeat = new Date();
+                    }
+                });
+            }, GUARDED_JOB_HEARTBEAT);
+            try {
+                return await job();
+            }
+            finally {
+                // Stop heartbeat
+                clearInterval(heartbeat);
+                // Remove the persisted job state:
+                await db.transaction('rw!', jobsTableName, async () => {
+                    const currentWork = await jobsTable.get(jobName);
+                    if (currentWork && currentWork.nodeId === myId) {
+                        await jobsTable.delete(jobName);
+                    }
+                });
+            }
+        }
+    }
+
     const ongoingSyncs = new WeakMap();
     function syncIfPossible(db, cloudOptions, cloudSchema, options) {
         const ongoing = ongoingSyncs.get(db);
@@ -5794,7 +5786,7 @@
             currentUserEmitter.next(UNAUTHORIZED_USER);
         });
         dexie.cloud = {
-            version: '4.0.0-beta.16',
+            version: '4.0.0-beta.17',
             options: { ...DEFAULT_OPTIONS },
             schema: null,
             serverState: null,
@@ -6036,7 +6028,7 @@
             }
         }
     }
-    dexieCloud.version = '4.0.0-beta.16';
+    dexieCloud.version = '4.0.0-beta.17';
     Dexie__default["default"].Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: