dexie-cloud-addon 4.4.4 → 4.4.5

package/dist/umd/dexie-cloud-client.d.ts

@@ -0,0 +1,23 @@
+import Dexie from 'dexie';
+import './extend-dexie-interface';
+import { DexieCloudSyncOptions } from './DexieCloudSyncOptions';
+import { SyncState } from './types/SyncState';
+import { DXCWebSocketStatus } from './DXCWebSocketStatus';
+import { UserLogin } from './db/entities/UserLogin';
+export { DexieCloudTable } from './DexieCloudTable';
+export * from './getTiedRealmId';
+export { DBRealm, DBRealmMember, DBRealmRole, DBSyncedObject, DBPermissionSet, } from 'dexie-cloud-common';
+export { resolveText } from './helpers/resolveText';
+export { Invite } from './Invite';
+export type { UserLogin, DXCWebSocketStatus, SyncState };
+export type { DexieCloudSyncOptions };
+export type { DexieCloudOptions, PeriodicSyncOptions } from './DexieCloudOptions';
+export * from './types/DXCAlert';
+export * from './types/DXCInputField';
+export * from './types/DXCUserInteraction';
+export { defineYDocTrigger } from './define-ydoc-trigger';
+export declare function dexieCloud(dexie: Dexie): void;
+export declare namespace dexieCloud {
+    var version: any;
+}
+export default dexieCloud;

package/dist/umd/errors/HttpError.d.ts

@@ -0,0 +1,5 @@
+export declare class HttpError extends Error {
+    httpStatus: number;
+    constructor(res: Response, message?: string);
+    get name(): string;
+}

package/dist/umd/extend-dexie-interface.d.ts

@@ -0,0 +1,23 @@
+import { DBRealm, DBRealmMember, DBRealmRole } from 'dexie-cloud-common';
+import { DexieCloudAPI } from './DexieCloudAPI';
+import { NewIdOptions } from './types/NewIdOptions';
+type Optional<T, Props extends keyof T> = Omit<T, Props> & Partial<T>;
+declare module 'dexie' {
+    interface Dexie {
+        cloud: DexieCloudAPI;
+        realms: Table<DBRealm, string, Optional<DBRealm, 'realmId' | 'owner'>>;
+        members: Table<DBRealmMember, string, Optional<DBRealmMember, 'id' | 'owner'>>;
+        roles: Table<DBRealmRole, [string, string], Optional<DBRealmRole, 'owner'>>;
+    }
+    interface Table {
+        newId(options: NewIdOptions): string;
+        idPrefix(): string;
+    }
+    interface DexieConstructor {
+        Cloud: {
+            (db: Dexie): void;
+            version: string;
+        };
+    }
+}
+export {};

package/dist/umd/getGlobalRolesObservable.d.ts

@@ -0,0 +1,5 @@
+import Dexie from 'dexie';
+import { DBRealmRole } from 'dexie-cloud-common';
+export declare const getGlobalRolesObservable: (x: Dexie) => import("./mapValueObservable").ObservableWithCurrentValue<{
+    [roleName: string]: DBRealmRole;
+}>;

package/dist/umd/getInternalAccessControlObservable.d.ts

@@ -0,0 +1,12 @@
+import Dexie from 'dexie';
+import { DBRealm, DBRealmMember } from 'dexie-cloud-common';
+export type InternalAccessControlData = {
+    readonly selfMembers: DBRealmMember[];
+    readonly realms: DBRealm[];
+    readonly userId: string;
+};
+export declare const getInternalAccessControlObservable: (x: Dexie) => import("./mapValueObservable").ObservableWithCurrentValue<{
+    selfMembers: DBRealmMember[];
+    realms: DBRealm[];
+    userId: string;
+}>;

package/dist/umd/getInvitesObservable.d.ts

@@ -0,0 +1,23 @@
+import { Dexie } from 'dexie';
+export declare const getInvitesObservable: (x: Dexie) => import("./mapValueObservable").ObservableWithCurrentValue<{
+    accept(): Promise<void>;
+    reject(): Promise<void>;
+    id: string;
+    userId?: string;
+    email?: string;
+    name?: string;
+    invite?: boolean;
+    invitedDate?: Date;
+    invitedBy?: {
+        name: string;
+        email: string;
+        userId: string;
+    };
+    accepted?: Date;
+    rejected?: Date;
+    roles?: string[];
+    permissions?: import("dexie-cloud-common").DBPermissionSet;
+    realmId: string;
+    owner: string;
+    $ts?: number;
+}[]>;

package/dist/umd/getPermissionsLookupObservable.d.ts

@@ -0,0 +1,16 @@
+import Dexie from 'dexie';
+import { DBPermissionSet, DBRealm } from 'dexie-cloud-common';
+import { Observable } from 'rxjs';
+export type PermissionsLookup = {
+    [realmId: string]: DBRealm & {
+        permissions: DBPermissionSet;
+    };
+};
+export type PermissionsLookupObservable = Observable<PermissionsLookup> & {
+    getValue(): PermissionsLookup;
+};
+export declare const getPermissionsLookupObservable: (x: Dexie) => import("./mapValueObservable").ObservableWithCurrentValue<{
+    [x: string]: DBRealm & {
+        permissions: DBPermissionSet;
+    };
+}>;

package/dist/umd/getTiedRealmId.d.ts

@@ -0,0 +1,2 @@
+export declare function getTiedRealmId(objectId: string): string;
+export declare function getTiedObjectId(realmId: string): string | null;

package/dist/umd/helpers/BroadcastedAndLocalEvent.d.ts

@@ -0,0 +1,8 @@
+import { Observable } from "rxjs";
+import { SWBroadcastChannel } from "./SWBroadcastChannel";
+export declare class BroadcastedAndLocalEvent<T> extends Observable<T> {
+    name: string;
+    bc: BroadcastChannel | SWBroadcastChannel;
+    constructor(name: string);
+    next(message: T): void;
+}

package/dist/umd/helpers/CancelToken.d.ts

@@ -0,0 +1,4 @@
+export interface CancelToken {
+    cancelled: boolean;
+}
+export declare function throwIfCancelled(cancelToken?: CancelToken): void;

package/dist/umd/helpers/IS_SERVICE_WORKER.d.ts

@@ -0,0 +1 @@
+export declare const IS_SERVICE_WORKER: false;

package/dist/umd/helpers/SWBroadcastChannel.d.ts

@@ -0,0 +1,12 @@
+/** This class is a fallback for browsers that lacks BroadcastChannel but have
+ * service workers (which is Safari versions 11.1 through 15.3).
+ * Safari 15.4 with BroadcastChannel was released on 2022-03-14.
+ * We might be able to remove this class in a near future as Safari < 15.4 is
+ * already very low in market share as of 2023-03-10.
+ */
+export declare class SWBroadcastChannel {
+    name: string;
+    constructor(name: string);
+    subscribe(listener: (message: any) => void): () => void;
+    postMessage(message: any): void;
+}

package/dist/umd/helpers/allSettled.d.ts

@@ -0,0 +1 @@
+export declare function allSettled(possiblePromises: any[]): Promise<unknown>;

package/dist/umd/helpers/bulkUpdate.d.ts

@@ -0,0 +1,4 @@
+import { Table } from 'dexie';
+export declare function bulkUpdate(table: Table, keys: any[], changeSpecs: {
+    [keyPath: string]: any;
+}[]): Promise<void>;

package/dist/umd/helpers/computeRealmSetHash.d.ts

@@ -0,0 +1,2 @@
+import { PersistedSyncState } from '../db/entities/PersistedSyncState';
+export declare function computeRealmSetHash({ realms, inviteRealms, }: PersistedSyncState): Promise<string>;

package/dist/umd/helpers/date-constants.d.ts

@@ -0,0 +1,5 @@
+export declare const SECONDS = 1000;
+export declare const MINUTES: number;
+export declare const HOURS: number;
+export declare const DAYS: number;
+export declare const WEEKS: number;

package/dist/umd/helpers/flatten.d.ts

@@ -0,0 +1 @@
+export declare function flatten<T>(a: (T | T[])[]): T[];

package/dist/umd/helpers/getMutationTable.d.ts

@@ -0,0 +1 @@
+export declare function getMutationTable(tableName: string): string;

package/dist/umd/helpers/getSyncableTables.d.ts

@@ -0,0 +1,4 @@
+import { Table } from "dexie";
+import { DexieCloudDB } from "../db/DexieCloudDB";
+import { EntityCommon } from "../db/entities/EntityCommon";
+export declare function getSyncableTables(db: DexieCloudDB): Table<EntityCommon>[];

package/dist/umd/helpers/getTableFromMutationTable.d.ts

@@ -0,0 +1 @@
+export declare function getTableFromMutationTable(mutationTable: string): string;

package/dist/umd/helpers/makeArray.d.ts

@@ -0,0 +1 @@
+export declare function makeArray<T>(iterable: Iterable<T>): T[];

package/dist/umd/helpers/randomString.d.ts

@@ -0,0 +1 @@
+export declare function randomString(bytes: number): string;

package/dist/umd/helpers/resolveText.d.ts

@@ -0,0 +1,16 @@
+import { DXCAlert } from "../types/DXCAlert";
+/** Resolve a message template with parameters.
+ *
+ * Example:
+ *  resolveText({
+ *    message: "Hello {name}!",
+ *    messageCode: "HELLO",
+ *    messageParams: {name: "David"}
+ *  }) => "Hello David!"
+ *
+ * @param message Template message with {vars} in it.
+ * @param messageCode Unique code for the message. Can be used for translation.
+ * @param messageParams Parameters to be used in the message.
+ * @returns A final message where parameters have been replaced with values.
+ */
+export declare function resolveText({ message, messageCode, messageParams }: DXCAlert): string;

package/dist/umd/helpers/throwVersionIncrementNeeded.d.ts

@@ -0,0 +1 @@
+export declare function throwVersionIncrementNeeded(): void;

package/dist/umd/helpers/visibilityState.d.ts

@@ -0,0 +1 @@
+export declare function createVisibilityStateObservable(): import("rxjs").Observable<DocumentVisibilityState>;

package/dist/umd/isEagerSyncDisabled.d.ts

@@ -0,0 +1,2 @@
+import { DexieCloudDB } from './db/DexieCloudDB';
+export declare function isEagerSyncDisabled(db: DexieCloudDB): boolean;

package/dist/umd/isFirefox.d.ts

@@ -0,0 +1 @@
+export declare const isFirefox: boolean;

package/dist/umd/isSafari.d.ts

@@ -0,0 +1,2 @@
+export declare const isSafari: boolean;
+export declare const safariVersion: number;

package/dist/umd/mapValueObservable.d.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+export interface ObservableWithCurrentValue<T> extends Observable<T> {
+    getValue(): T;
+}
+export declare function mapValueObservable<T, R>(o: ObservableWithCurrentValue<T>, mapper: (x: T) => R): ObservableWithCurrentValue<R>;

package/dist/umd/mergePermissions.d.ts

@@ -0,0 +1,2 @@
+import { DBPermissionSet } from 'dexie-cloud-common';
+export declare function mergePermissions(...permissions: DBPermissionSet[]): DBPermissionSet;

package/dist/umd/middleware-helpers/guardedTable.d.ts

@@ -0,0 +1,11 @@
+import { DBCoreTable } from "dexie";
+export declare function guardedTable(table: DBCoreTable): {
+    count: (req: import("dexie").DBCoreCountRequest) => Promise<number>;
+    get: (req: import("dexie").DBCoreGetRequest) => Promise<any>;
+    getMany: (req: import("dexie").DBCoreGetManyRequest) => Promise<any[]>;
+    openCursor: (req: import("dexie").DBCoreOpenCursorRequest) => Promise<import("dexie").DBCoreCursor | null>;
+    query: (req: import("dexie").DBCoreQueryRequest) => Promise<import("dexie").DBCoreQueryResponse>;
+    mutate: (req: import("dexie").DBCoreMutateRequest) => Promise<import("dexie").DBCoreMutateResponse>;
+    name: string;
+    schema: import("dexie").DBCoreTableSchema;
+};

package/dist/umd/middleware-helpers/idGenerationHelpers.d.ts

@@ -0,0 +1,18 @@
+import { DBCoreAddRequest, DBCoreDeleteRequest, DBCoreIndex, DBCorePutRequest } from 'dexie';
+export declare function toStringTag(o: Object): any;
+export declare function getEffectiveKeys(primaryKey: DBCoreIndex, req: (Pick<DBCoreAddRequest | DBCorePutRequest, 'type' | 'values'> & {
+    keys?: any[];
+}) | Pick<DBCoreDeleteRequest, 'keys' | 'type'>): any[];
+export declare function generateTablePrefix(tableName: string, allPrefixes: Set<string>): string;
+/**
+ *
+ * @param prefix A unique 3-letter short-name of the table.
+ * @param shardKey 3 last letters from another ID if colocation is requested. Verified on server on inserts - guarantees unique IDs across shards.
+ *  The shardKey part of the key represent the shardId where it was first created. An object with this
+ *  primary key can later on be moved to another shard without being altered. The reason for having
+ *  the origin shardKey as part of the key, is that the server will not need to check uniqueness constraint
+ *  across all shards on every insert. Updates / moves across shards are already controlled by the server
+ *  in the sense that the objects needs to be there already - we only need this part for inserts.
+ * @returns
+ */
+export declare function generateKey(prefix: string, shardKey?: string): string;

package/dist/umd/middlewares/createIdGenerationMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { DBCore, Middleware } from 'dexie';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function createIdGenerationMiddleware(db: DexieCloudDB): Middleware<DBCore>;

package/dist/umd/middlewares/createImplicitPropSetterMiddleware.d.ts

@@ -0,0 +1,3 @@
+import { DBCore, Middleware } from 'dexie';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+export declare function createImplicitPropSetterMiddleware(db: DexieCloudDB): Middleware<DBCore>;

package/dist/umd/middlewares/createMutationTrackingMiddleware.d.ts

@@ -0,0 +1,17 @@
+import { DBCore, Middleware } from 'dexie';
+import { BehaviorSubject } from 'rxjs';
+import { DexieCloudDB } from '../db/DexieCloudDB';
+import { UserLogin } from '../db/entities/UserLogin';
+export interface MutationTrackingMiddlewareArgs {
+    currentUserObservable: BehaviorSubject<UserLogin>;
+    db: DexieCloudDB;
+}
+/** Tracks all mutations in the same transaction as the mutations -
+ * so it is guaranteed that no mutation goes untracked - and if transaction
+ * aborts, the mutations won't be tracked.
+ *
+ * The sync job will use the tracked mutations as the source of truth when pushing
+ * changes to server and cleanup the tracked mutations once the server has
+ * ackowledged that it got them.
+ */
+export declare function createMutationTrackingMiddleware({ currentUserObservable, db, }: MutationTrackingMiddlewareArgs): Middleware<DBCore>;

package/dist/umd/middlewares/outstandingTransaction.d.ts

@@ -0,0 +1,4 @@
+import { DBCoreTransaction } from 'dexie';
+import { BehaviorSubject } from 'rxjs';
+import { TXExpandos } from '../types/TXExpandos';
+export declare const outstandingTransactions: BehaviorSubject<Set<DBCoreTransaction & IDBTransaction & TXExpandos>>;

package/dist/umd/overrideParseStoresSpec.d.ts

@@ -0,0 +1,4 @@
+import Dexie, { DbSchema } from 'dexie';
+export declare function overrideParseStoresSpec(origFunc: Function, dexie: Dexie): (stores: {
+    [tableName: string]: string;
+}, dbSchema: DbSchema) => any;

package/dist/umd/performInitialSync.d.ts

@@ -0,0 +1,4 @@
+import { DexieCloudSchema } from 'dexie-cloud-common';
+import { DexieCloudDB } from './db/DexieCloudDB';
+import { DexieCloudOptions } from './DexieCloudOptions';
+export declare function performInitialSync(db: DexieCloudDB, cloudOptions: DexieCloudOptions, cloudSchema: DexieCloudSchema): Promise<void>;

package/dist/umd/permissions.d.ts

@@ -0,0 +1,9 @@
+import Dexie from 'dexie';
+import { Observable } from 'rxjs';
+import { PermissionChecker } from './PermissionChecker';
+import './extend-dexie-interface';
+export declare function permissions(dexie: Dexie, obj: {
+    owner?: string;
+    realmId?: string;
+    table?: () => string;
+}, tableName?: string): Observable<PermissionChecker<any>>;

package/dist/umd/prodLog.d.ts

@@ -0,0 +1,9 @@
+/** A way to log to console in production without terser stripping out
+ * it from the release bundle.
+ * This should be used very rarely and only in places where it's
+ * absolutely necessary to log something in production.
+ *
+ * @param level
+ * @param args
+ */
+export declare function prodLog(level: 'log' | 'warn' | 'error' | 'debug', ...args: any[]): void;

package/dist/umd/service-worker.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/umd/service-worker.js

@@ -8,7 +8,7 @@
  *
  * ==========================================================================
  *
- * Version 4.4.4, Wed Mar 25 2026
+ * Version 4.4.5, Wed Mar 25 2026
  *
  * https://dexie.org
  *
@@ -18003,14 +18003,13 @@
             throw new Error(`No database URL to connect WebSocket to`);
         }
         const readyForChangesMessage = db.messageConsumer.readyToServe.pipe(operators.filter((isReady) => isReady), // When consumer is ready for new messages, produce such a message to inform server about it
-        operators.switchMap(() => db.getPersistedSyncState()), // We need the info on which server revision we are at:
-        operators.filter((syncState) => syncState && syncState.serverRevision), // We wont send anything to server before inital sync has taken place
+        operators.switchMap(() => db.cloud.persistedSyncState.pipe(operators.filter((syncState) => !!(syncState && syncState.serverRevision)), operators.take(1))), // Wait reactively for syncState with serverRevision (avoids race with logout/re-sync)
         operators.switchMap((syncState) => __awaiter(this, void 0, void 0, function* () {
             return ({
                 // Produce the message to trigger server to send us new messages to consume:
                 type: 'ready',
                 rev: syncState.serverRevision,
-                realmSetHash: yield computeRealmSetHash(syncState)
+                realmSetHash: yield computeRealmSetHash(syncState),
             });
         })));
         const messageProducer = rxjs.merge(readyForChangesMessage, db.messageProducer);
@@ -18023,7 +18022,8 @@
                 }*/
                 return userIsReallyActive.pipe(operators.map((isActive) => [isActive ? userLogin : null, syncState]));
             }), operators.switchMap(([userLogin, syncState]) => {
-                if ((userLogin === null || userLogin === void 0 ? void 0 : userLogin.isLoggedIn) && !(syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId))) {
+                if ((userLogin === null || userLogin === void 0 ? void 0 : userLogin.isLoggedIn) &&
+                    !(syncState === null || syncState === void 0 ? void 0 : syncState.realms.includes(userLogin.userId))) {
                     // We're in an in-between state when user is logged in but the user's realms are not yet synced.
                     // Don't make this change reconnect the websocket just yet. Wait till syncState is updated
                     // to iclude the user's realm.
@@ -18058,7 +18058,7 @@
                             accessTokenExpiration: refreshedLogin.accessTokenExpiration,
                             claims: refreshedLogin.claims,
                             license: refreshedLogin.license,
-                            data: refreshedLogin.data
+                            data: refreshedLogin.data,
                         });
                     })), operators.switchMap(() => createObservable()));
                 }
@@ -18066,7 +18066,7 @@
                     return rxjs.throwError(() => error);
                 }
             }), operators.catchError((error) => {
-                db.cloud.webSocketStatus.next("error");
+                db.cloud.webSocketStatus.next('error');
                 if (error instanceof InvalidLicenseError) {
                     // Don't retry. Just throw and don't try connect again.
                     return rxjs.throwError(() => error);
@@ -18178,27 +18178,30 @@
             // break free from possible active transaction:
             setTimeout(() => {
                 const purpose = pullSignalled ? 'pull' : 'push';
+                pullSignalled = false;
+                pushSignalled = false;
                 syncStartTime = Date.now();
                 syncIfPossible(db, cloudOptions, cloudSchema, {
                     cancelToken,
                     retryImmediatelyOnFetchError: true, // workaround for "net::ERR_NETWORK_CHANGED" in chrome.
                     purpose,
-                }).then(() => {
+                })
+                    .then(() => {
                     if (cancelToken.cancelled) {
                         stop();
                     }
                     else {
                         if (pullSignalled || pushSignalled) {
                             // If we have signalled for more sync, do it now.
-                            pullSignalled = false;
-                            pushSignalled = false;
+                            // Note: don't reset flags here - syncAndRetry reads them in setTimeout
                             return syncAndRetry();
                         }
                     }
                     ongoingSync = false;
                     nextRetryTime = 0;
                     syncStartTime = 0;
-                }).catch((error) => {
+                })
+                    .catch((error) => {
                     console.error('error in syncIfPossible()', error);
                     if (cancelToken.cancelled) {
                         stop();
@@ -18241,7 +18244,8 @@
                 if (nextRetryTime) {
                     console.debug(`Sync is paused until ${new Date(nextRetryTime).toISOString()} due to error in last sync attempt`);
                 }
-                else if (syncStartTime > 0 && Date.now() - syncStartTime > 20 * SECONDS) {
+                else if (syncStartTime > 0 &&
+                    Date.now() - syncStartTime > 20 * SECONDS) {
                     console.debug(`An existing sync operation is taking more than 20 seconds. Will resync when done.`);
                 }
                 return;
@@ -19432,7 +19436,7 @@
         const downloading$ = createDownloadingState();
         dexie.cloud = {
             // @ts-ignore
-            version: "4.4.4",
+            version: "4.4.5",
             options: Object.assign({}, DEFAULT_OPTIONS),
             schema: null,
             get currentUserId() {
@@ -19859,7 +19863,7 @@
         }
     }
     // @ts-ignore
-    dexieCloud.version = "4.4.4";
+    dexieCloud.version = "4.4.5";
     Dexie.Cloud = dexieCloud;
 
     // In case the SW lives for a while, let it reuse already opened connections: