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

package/dist/umd/service-worker.js

@@ -4649,110 +4649,13 @@
         };
     }
 
-    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 = 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 rxjs.BehaviorSubject(true);
@@ -4766,9 +4669,13 @@
     //   for just a short time.
     const userIsReallyActive = new rxjs.BehaviorSubject(true);
     userIsActive
-        .pipe(switchMap((isActive) => isActive
-        ? rxjs.of(true)
-        : rxjs.of(false).pipe(delay(INACTIVE_WAIT_TIME))), distinctUntilChanged())
+        .pipe(switchMap((isActive) => {
+        //console.debug('SyncStatus: DUBB: isActive changed to', isActive);
+        return isActive
+            ? rxjs.of(true)
+            : rxjs.of(false).pipe(delay(INACTIVE_WAIT_TIME))
+                ;
+    }), distinctUntilChanged())
         .subscribe(userIsReallyActive);
     //
     // First create some corner-stone observables to build the flow on
@@ -4783,7 +4690,7 @@
     const documentBecomesVisible = visibilityStateIsChanged.pipe(filter(() => document.visibilityState === 'visible'));
     // Any of various user-activity-related events happen:
     const userDoesSomething = typeof window !== 'undefined'
-        ? rxjs.merge(documentBecomesVisible, rxjs.fromEvent(window, 'mousemove'), rxjs.fromEvent(window, 'keydown'), rxjs.fromEvent(window, 'wheel'), rxjs.fromEvent(window, 'touchmove'))
+        ? rxjs.merge(documentBecomesVisible, rxjs.fromEvent(window, 'mousedown'), rxjs.fromEvent(window, 'mousemove'), rxjs.fromEvent(window, 'keydown'), rxjs.fromEvent(window, 'wheel'), rxjs.fromEvent(window, 'touchmove'))
         : rxjs.of({});
     if (typeof document !== 'undefined') {
         //
@@ -4834,6 +4741,7 @@
         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;
@@ -4853,7 +4761,7 @@
             this.disconnect();
         }
         disconnect() {
-            this.webSocketStatus.next("disconnected");
+            this.webSocketStatus.next('disconnected');
             if (this.pinger) {
                 clearInterval(this.pinger);
                 this.pinger = null;
@@ -4871,11 +4779,18 @@
             }
         }
         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', {
@@ -4890,12 +4805,14 @@
             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.');
@@ -4942,7 +4859,7 @@
             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);
@@ -4981,23 +4898,30 @@
                 }
             };
             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));
                     }
@@ -5034,9 +4958,9 @@
             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.
@@ -5059,7 +4983,10 @@
                 else {
                     return rxjs.throwError(error);
                 }
-            }), catchError((error) => rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()))));
+            }), catchError((error) => {
+                db.cloud.webSocketStatus.next("error");
+                return rxjs.from(waitAndReconnectWhenUserDoesSomething(error)).pipe(switchMap(() => createObservable()));
+            }));
         }
         return createObservable().subscribe((msg) => {
             if (msg) {
@@ -5079,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);
@@ -5483,6 +5499,21 @@
         return rv;
     }
 
+    const getGlobalRolesObservable = associate((db) => {
+        return createSharedValueObservable(Dexie.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 rxjs.BehaviorSubject(UNAUTHORIZED_USER));
 
     const getInternalAccessControlObservable = associate((db) => {
@@ -5584,18 +5615,38 @@
     }
 
     const getPermissionsLookupObservable = associate((db) => {
-        const o = getInternalAccessControlObservable(db._novip);
-        return mapValueObservable(o, ({ selfMembers, realms, userId }) => {
+        const o = createSharedValueObservable(rxjs.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,
@@ -5679,7 +5730,7 @@
             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());
@@ -5708,6 +5759,7 @@
         //
         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) => {
@@ -5734,7 +5786,7 @@
             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,
@@ -5755,8 +5807,10 @@
                 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)}`;
@@ -5843,7 +5897,7 @@
                     db.getSchema(),
                     db.getPersistedSyncState(),
                 ]);
-                if (!options) {
+                if (!configuredProgramatically) {
                     // Options not specified programatically (use case for SW!)
                     // Take persisted options:
                     db.cloud.options = persistedOptions || null;
@@ -5851,6 +5905,8 @@
                 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 &&
@@ -5972,7 +6028,7 @@
             }
         }
     }
-    dexieCloud.version = '4.0.0-beta.14';
+    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: