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

package/dist/modern/dexie-cloud-addon.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.0.0-beta.14, Mon Dec 20 2021
+ * Version 4.0.0-beta.17, Fri Apr 08 2022
  *
  * https://dexie.org
  *
@@ -17,7 +17,7 @@
  */
 
 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';
 
 //@ts-check
 const randomFillSync = crypto.getRandomValues;
@@ -4660,110 +4660,13 @@ function overrideParseStoresSpec(origFunc, dexie) {
     };
 }
 
-const SECONDS = 1000;
-const MINUTES = 60 * SECONDS;
-
-const myId = randomString(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 = 300000; // 300_000;
+const USER_INACTIVITY_TIMEOUT = 180000; // 3 minutes
 const INACTIVE_WAIT_TIME = 20000;
 // This observable will be emitted to later down....
 const userIsActive = new BehaviorSubject(true);
@@ -4777,9 +4680,13 @@ const userIsActive = new BehaviorSubject(true);
 //   for just a short time.
 const userIsReallyActive = new BehaviorSubject(true);
 userIsActive
-    .pipe(switchMap((isActive) => isActive
-    ? of(true)
-    : of(false).pipe(delay(INACTIVE_WAIT_TIME))), distinctUntilChanged())
+    .pipe(switchMap((isActive) => {
+    //console.debug('SyncStatus: DUBB: isActive changed to', isActive);
+    return isActive
+        ? of(true)
+        : of(false).pipe(delay(INACTIVE_WAIT_TIME))
+            ;
+}), distinctUntilChanged())
     .subscribe(userIsReallyActive);
 //
 // First create some corner-stone observables to build the flow on
@@ -4794,7 +4701,7 @@ const documentBecomesHidden = visibilityStateIsChanged.pipe(filter(() => documen
 const documentBecomesVisible = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'visible'));
 // Any of various user-activity-related events happen:
 const userDoesSomething = typeof window !== 'undefined'
-    ? merge(documentBecomesVisible, fromEvent(window, 'mousemove'), fromEvent(window, 'keydown'), fromEvent(window, 'wheel'), fromEvent(window, 'touchmove'))
+    ? merge(documentBecomesVisible, fromEvent(window, 'mousedown'), fromEvent(window, 'mousemove'), fromEvent(window, 'keydown'), fromEvent(window, 'wheel'), fromEvent(window, 'touchmove'))
     : of({});
 if (typeof document !== 'undefined') {
     //
@@ -4845,6 +4752,7 @@ class WSConnection extends Subscription$1 {
     constructor(databaseUrl, rev, realmSetHash, clientIdentity, token, tokenExpiration, subscriber, messageProducer, webSocketStatus) {
         super(() => this.teardown());
         this.id = ++counter;
+        this.reconnecting = false;
         console.debug('New WebSocket Connection', this.id, token ? 'authorized' : 'unauthorized');
         this.databaseUrl = databaseUrl;
         this.rev = rev;
@@ -4864,7 +4772,7 @@ class WSConnection extends Subscription$1 {
         this.disconnect();
     }
     disconnect() {
-        this.webSocketStatus.next("disconnected");
+        this.webSocketStatus.next('disconnected');
         if (this.pinger) {
             clearInterval(this.pinger);
             this.pinger = null;
@@ -4882,11 +4790,18 @@ class WSConnection extends Subscription$1 {
         }
     }
     reconnect() {
-        this.disconnect();
-        this.connect();
+        if (this.reconnecting)
+            return;
+        this.reconnecting = true;
+        try {
+            this.disconnect();
+        }
+        catch { }
+        this.connect()
+            .catch(() => { })
+            .then(() => (this.reconnecting = false)); // finally()
     }
     async connect() {
-        this.webSocketStatus.next("connecting");
         this.lastServerActivity = new Date();
         if (this.pauseUntil && this.pauseUntil > new Date()) {
             console.debug('WS not reconnecting just yet', {
@@ -4901,12 +4816,14 @@ class WSConnection extends Subscription$1 {
         if (!this.databaseUrl)
             throw new Error(`Cannot connect without a database URL`);
         if (this.closed) {
+            //console.debug('SyncStatus: DUBB: Ooops it was closed!');
             return;
         }
         if (this.tokenExpiration && this.tokenExpiration < new Date()) {
             this.subscriber.error(new TokenExpiredError()); // Will be handled in connectWebSocket.ts.
             return;
         }
+        this.webSocketStatus.next('connecting');
         this.pinger = setInterval(async () => {
             if (this.closed) {
                 console.debug('pinger check', this.id, 'CLOSED.');
@@ -4953,7 +4870,7 @@ class WSConnection extends Subscription$1 {
         const searchParams = new URLSearchParams();
         if (this.subscriber.closed)
             return;
-        searchParams.set('v', "2");
+        searchParams.set('v', '2');
         searchParams.set('rev', this.rev);
         searchParams.set('realmsHash', this.realmSetHash);
         searchParams.set('clientId', this.clientIdentity);
@@ -4992,23 +4909,30 @@ class WSConnection extends Subscription$1 {
             }
         };
         try {
+            let everConnected = false;
             await new Promise((resolve, reject) => {
                 ws.onopen = (event) => {
                     console.debug('dexie-cloud WebSocket onopen');
+                    everConnected = true;
                     resolve(null);
                 };
                 ws.onerror = (event) => {
-                    const error = event.error || new Error('WebSocket Error');
-                    this.disconnect();
-                    this.subscriber.error(error);
-                    this.webSocketStatus.next("error");
-                    reject(error);
+                    if (!everConnected) {
+                        const error = event.error || new Error('WebSocket Error');
+                        this.subscriber.error(error);
+                        this.webSocketStatus.next('error');
+                        reject(error);
+                    }
+                    else {
+                        this.reconnect();
+                    }
                 };
             });
-            this.messageProducerSubscription = this.messageProducer.subscribe(msg => {
+            this.messageProducerSubscription = this.messageProducer.subscribe((msg) => {
                 if (!this.closed) {
-                    if (msg.type === 'ready' && this.webSocketStatus.value !== 'connected') {
-                        this.webSocketStatus.next("connected");
+                    if (msg.type === 'ready' &&
+                        this.webSocketStatus.value !== 'connected') {
+                        this.webSocketStatus.next('connected');
                     }
                     this.ws?.send(TSON.stringify(msg));
                 }
@@ -5045,9 +4969,9 @@ function connectWebSocket(db) {
         rev: syncState.serverRevision,
     })));
     function createObservable() {
-        return db.cloud.persistedSyncState.pipe(filter(syncState => syncState?.serverRevision), // Don't connect before there's no initial sync performed.
+        return db.cloud.persistedSyncState.pipe(filter((syncState) => syncState?.serverRevision), // Don't connect before there's no initial sync performed.
         take(1), // Don't continue waking up whenever syncState change
-        switchMap((syncState) => db.cloud.currentUser.pipe(map(userLogin => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]))), switchMap(async ([userLogin, syncState]) => [userLogin, await computeRealmSetHash(syncState)]), switchMap(([userLogin, realmSetHash]) => 
+        switchMap((syncState) => db.cloud.currentUser.pipe(map((userLogin) => [userLogin, syncState]))), switchMap(([userLogin, syncState]) => userIsReallyActive.pipe(map((isActive) => [isActive ? userLogin : null, syncState]))), switchMap(async ([userLogin, syncState]) => [userLogin, await computeRealmSetHash(syncState)]), switchMap(([userLogin, realmSetHash]) => 
         // Let server end query changes from last entry of same client-ID and forward.
         // If no new entries, server won't bother the client. If new entries, server sends only those
         // and the baseRev of the last from same client-ID.
@@ -5070,7 +4994,10 @@ function connectWebSocket(db) {
             else {
                 return throwError(error);
             }
-        }), catchError((error) => from$1(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()))));
+        }), catchError((error) => {
+            db.cloud.webSocketStatus.next("error");
+            return from$1(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
+        }));
     }
     return createObservable().subscribe((msg) => {
         if (msg) {
@@ -5090,6 +5017,95 @@ async function isSyncNeeded(db) {
         : false;
 }
 
+const SECONDS = 1000;
+const MINUTES = 60 * SECONDS;
+
+const myId = randomString(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);
@@ -5494,6 +5510,21 @@ function createSharedValueObservable(o, defaultValue) {
     return rv;
 }
 
+const getGlobalRolesObservable = associate((db) => {
+    return createSharedValueObservable(liveQuery(() => db.roles
+        .where({ realmId: 'rlm-public' })
+        .toArray()
+        .then((roles) => {
+        const rv = {};
+        for (const role of roles
+            .slice()
+            .sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0))) {
+            rv[role.name] = role;
+        }
+        return rv;
+    })), {});
+});
+
 const getCurrentUserEmitter = associate((db) => new BehaviorSubject(UNAUTHORIZED_USER));
 
 const getInternalAccessControlObservable = associate((db) => {
@@ -5595,18 +5626,38 @@ function mergePermissions(...permissions) {
 }
 
 const getPermissionsLookupObservable = associate((db) => {
-    const o = getInternalAccessControlObservable(db._novip);
-    return mapValueObservable(o, ({ selfMembers, realms, userId }) => {
+    const o = createSharedValueObservable(combineLatest([
+        getInternalAccessControlObservable(db._novip),
+        getGlobalRolesObservable(db._novip),
+    ]).pipe(map(([{ selfMembers, realms, userId }, globalRoles]) => ({
+        selfMembers,
+        realms,
+        userId,
+        globalRoles,
+    }))), {
+        selfMembers: [],
+        realms: [],
+        userId: UNAUTHORIZED_USER.userId,
+        globalRoles: {},
+    });
+    return mapValueObservable(o, ({ selfMembers, realms, userId, globalRoles }) => {
         const rv = realms
-            .map((realm) => ({
-            ...realm,
-            permissions: realm.owner === userId
-                ? { manage: '*' }
-                : mergePermissions(...selfMembers
-                    .filter((m) => m.realmId === realm.realmId)
-                    .map((m) => m.permissions)
-                    .filter((p) => p)),
-        }))
+            .map((realm) => {
+            const selfRealmMembers = selfMembers.filter((m) => m.realmId === realm.realmId);
+            const directPermissionSets = selfRealmMembers
+                .map((m) => m.permissions)
+                .filter((p) => p);
+            const rolePermissionSets = flatten(selfRealmMembers.map((m) => m.roles).filter((roleName) => roleName))
+                .map((role) => globalRoles[role])
+                .filter((role) => role)
+                .map((role) => role.permissions);
+            return {
+                ...realm,
+                permissions: realm.owner === userId
+                    ? { manage: '*' }
+                    : mergePermissions(...directPermissionSets, ...rolePermissionSets),
+            };
+        })
             .reduce((p, c) => ({ ...p, [c.realmId]: c }), {
             [userId]: {
                 realmId: userId,
@@ -5690,7 +5741,7 @@ function permissions(dexie, obj, tableName) {
         const realm = permissionsLookup[realmId || dexie.cloud.currentUserId];
         if (!realm)
             return new PermissionChecker({}, tableName, !owner || owner === dexie.cloud.currentUserId);
-        return new PermissionChecker(realm.permissions, tableName, !owner || owner === dexie.cloud.currentUserId);
+        return new PermissionChecker(realm.permissions, tableName, realmId === dexie.cloud.currentUserId || owner === dexie.cloud.currentUserId);
     };
     const o = source.pipe(map(mapper));
     o.getValue = () => mapper(source.getValue());
@@ -5726,6 +5777,7 @@ function dexieCloud(dexie) {
     //
     const currentUserEmitter = getCurrentUserEmitter(dexie);
     const subscriptions = [];
+    let configuredProgramatically = false;
     // local sync worker - used when there's no service worker.
     let localSyncWorker = null;
     dexie.on('ready', async (dexie) => {
@@ -5752,7 +5804,7 @@ function dexieCloud(dexie) {
         currentUserEmitter.next(UNAUTHORIZED_USER);
     });
     dexie.cloud = {
-        version: '4.0.0-beta.14',
+        version: '4.0.0-beta.17',
         options: { ...DEFAULT_OPTIONS },
         schema: null,
         serverState: null,
@@ -5773,8 +5825,10 @@ function dexieCloud(dexie) {
             await login(db, hint);
         },
         invites: getInvitesObservable(dexie),
+        roles: getGlobalRolesObservable(dexie),
         configure(options) {
             options = dexie.cloud.options = { ...dexie.cloud.options, ...options };
+            configuredProgramatically = true;
             if (options.databaseUrl && options.nameSuffix) {
                 // @ts-ignore
                 dexie.name = `${origIdbName}-${getDbNameFromDbUrl(options.databaseUrl)}`;
@@ -5861,7 +5915,7 @@ function dexieCloud(dexie) {
                 db.getSchema(),
                 db.getPersistedSyncState(),
             ]);
-            if (!options) {
+            if (!configuredProgramatically) {
                 // Options not specified programatically (use case for SW!)
                 // Take persisted options:
                 db.cloud.options = persistedOptions || null;
@@ -5869,6 +5923,8 @@ function dexieCloud(dexie) {
             else if (!persistedOptions ||
                 JSON.stringify(persistedOptions) !== JSON.stringify(options)) {
                 // Update persisted options:
+                if (!options)
+                    throw new Error(`Internal error`); // options cannot be null if configuredProgramatically is set.
                 await db.$syncState.put(options, 'options');
             }
             if (db.cloud.options?.tryUseServiceWorker &&
@@ -5990,7 +6046,7 @@ function dexieCloud(dexie) {
         }
     }
 }
-dexieCloud.version = '4.0.0-beta.14';
+dexieCloud.version = '4.0.0-beta.17';
 Dexie.Cloud = dexieCloud;
 
 export { dexieCloud as default, dexieCloud, getTiedObjectId, getTiedRealmId };