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

package/dist/modern/service-worker.js

@@ -1,5 +1,5 @@
 import Dexie, { cmp, liveQuery } from 'dexie';
-import { Observable as Observable$1, BehaviorSubject, Subject, from as from$1, fromEvent, of, merge, Subscription as Subscription$1, throwError, combineLatest, map as map$1, share, timer as timer$1, switchMap as switchMap$1 } from 'rxjs';
+import { Observable as Observable$1, BehaviorSubject, Subject, fromEvent, of, merge, Subscription as Subscription$1, from as from$1, throwError, combineLatest, map as map$1, share, timer as timer$1, switchMap as switchMap$1 } from 'rxjs';
 
 const UNAUTHORIZED_USER = {
     userId: "unauthorized",
@@ -4642,107 +4642,10 @@ function overrideParseStoresSpec(origFunc, dexie) {
     };
 }
 
-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 = from$1(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
@@ -5096,6 +4999,95 @@ async function isSyncNeeded(db) {
         : 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 = from$1(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);
@@ -5787,7 +5779,7 @@ function dexieCloud(dexie) {
         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,
@@ -6029,7 +6021,7 @@ function dexieCloud(dexie) {
         }
     }
 }
-dexieCloud.version = '4.0.0-beta.16';
+dexieCloud.version = '4.0.0-beta.17';
 Dexie.Cloud = dexieCloud;
 
 // In case the SW lives for a while, let it reuse already opened connections: