@pmate/chat-sdk 0.12.0-next.20 → 0.12.0-next.22

package/lib/runtime/durableSender.js

@@ -5,8 +5,15 @@ import { messageScopeKey } from "./messageStore.js";
 export class DurableChatSender {
     client;
     onError;
+    options;
     db;
     outbox;
+    epochs;
+    version = 0;
+    withdrawn = false;
+    revoking;
+    channel;
+    accepted = new Set();
     scope;
     identity;
     values = new Map();
@@ -14,30 +21,129 @@ export class DurableChatSender {
     listeners = new Set();
     running = new Map();
     closed = false;
+    closing = false;
+    empty = [];
     offConnection;
     ready;
     constructor(client, scope, onError, options = {}) {
         this.client = client;
         this.onError = onError;
+        this.options = options;
         this.scope = messageScopeKey(scope);
         this.identity = { ...scope };
         this.db = new Dexie(options.name ?? "pmate-chat-outbox", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
         this.db.version(1).stores({ outbox: "[scope+hash],scope,[scope+threadId]" });
+        this.db.version(2).stores({ scopeEpochs: "scope" });
         this.outbox = this.db.table("outbox");
-        this.ready = this.outbox.where("scope").equals(this.scope).toArray().then(records => {
-            if (this.closed)
-                return;
-            records.filter(record => !record.confirmed).forEach(record => this.values.set(record.hash, record));
-            this.emit();
-        });
+        this.epochs = this.db.table("scopeEpochs");
+        this.db.on("versionchange", () => { this.db.close({ disableAutoOpen: false }); return false; });
+        this.ready = this.restore();
+        void this.ready.catch(() => { });
+        if (typeof BroadcastChannel !== "undefined") {
+            this.channel = new BroadcastChannel(`pmate-chat-outbox:${this.scope}:${this.db.name}`);
+            this.channel.onmessage = event => { if (Number.isSafeInteger(event.data?.version) && event.data.version > this.version)
+                this.withdraw(); };
+        }
         this.offConnection = client.watchConnection(state => {
             if (state === "connected")
                 void this.resume().catch(onError);
         });
     }
+    async readAccess() {
+        const access = await this.options.access?.();
+        if (access && (!Number.isSafeInteger(access.version) || access.version < 0 || typeof access.allowed !== "boolean"))
+            throw new Error("INVALID_OUTBOX_ACCESS");
+        return access;
+    }
+    async restore() {
+        const access = await this.readAccess();
+        const loaded = await this.db.transaction("rw", this.outbox, this.epochs, async () => {
+            const current = (await this.epochs.get(this.scope))?.version ?? 0;
+            const version = access?.version ?? current;
+            if (version < current)
+                throw new Error("OUTBOX_SCOPE_CHANGED");
+            if (version > current) {
+                await this.epochs.put({ scope: this.scope, version });
+                await this.deleteRows();
+            }
+            return { version, advanced: version > current, records: access?.allowed === false ? [] : await this.outbox.where("scope").equals(this.scope).toArray() };
+        });
+        this.version = loaded.version;
+        if (loaded.advanced)
+            this.channel?.postMessage({ version: this.version });
+        if (this.closed || this.withdrawn)
+            return;
+        const current = await this.readAccess();
+        if (current && (!current.allowed || current.version !== this.version))
+            return;
+        loaded.records.filter(record => !record.confirmed && (record.accessVersion ?? 0) === this.version).forEach(record => this.values.set(record.hash, record));
+        this.emit();
+    }
+    async checkAccess() {
+        if (this.closed)
+            throw new Error("CHAT_SENDER_CLOSED");
+        if (this.withdrawn)
+            throw new Error("OUTBOX_ACCESS_REVOKED");
+        const access = await this.readAccess();
+        if (access && access.version !== this.version) {
+            this.withdraw();
+            throw new Error("OUTBOX_SCOPE_CHANGED");
+        }
+        if (access && !access.allowed)
+            throw new Error("OUTBOX_ACCESS_REVOKED");
+    }
+    async withEpoch(mode, operation) {
+        await this.checkAccess();
+        try {
+            return await this.db.transaction(mode, this.outbox, this.epochs, async () => {
+                if (this.closed || this.withdrawn)
+                    throw new Error("OUTBOX_ACCESS_REVOKED");
+                if (((await this.epochs.get(this.scope))?.version ?? 0) !== this.version)
+                    throw new Error("OUTBOX_SCOPE_CHANGED");
+                return operation();
+            });
+        }
+        catch (error) {
+            if (String(error).includes("OUTBOX_SCOPE_CHANGED"))
+                this.withdraw();
+            throw error;
+        }
+    }
+    deleteRows() { return this.outbox.where("[scope+hash]").between([this.scope, Dexie.minKey], [this.scope, Dexie.maxKey], true, true).delete(); }
+    /** Stop disclosure immediately; durable invalidation is coordinated separately. */
+    withdraw() {
+        this.withdrawn = true;
+        this.values.clear();
+        this.emit();
+    }
+    revoke(targetVersion) {
+        if (this.closed || this.closing)
+            return Promise.reject(new Error("CHAT_SENDER_CLOSED"));
+        if (this.revoking)
+            return this.revoking;
+        this.withdraw();
+        return this.revoking = (async () => {
+            await this.ready.catch(error => { if (!String(error).includes("OUTBOX_SCOPE_CHANGED"))
+                throw error; });
+            const version = await this.db.transaction("rw", this.outbox, this.epochs, async () => {
+                const current = (await this.epochs.get(this.scope))?.version ?? 0;
+                const target = targetVersion ?? this.version + 1;
+                if (!Number.isSafeInteger(target) || target < 0)
+                    throw new Error("INVALID_OUTBOX_EPOCH");
+                if (current >= target)
+                    return current;
+                await this.epochs.put({ scope: this.scope, version: target });
+                await this.deleteRows();
+                return target;
+            });
+            this.channel?.postMessage({ version });
+        })();
+    }
     initialize() { return this.ready; }
     subscribe(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
     snapshot(threadId) {
+        if (this.closed || this.closing || this.withdrawn)
+            return this.empty;
         let snapshot = this.snapshots.get(threadId);
         if (!snapshot) {
             snapshot = [...this.values.values()].filter(record => threadId === undefined || record.threadId === threadId);
@@ -50,7 +156,8 @@ export class DurableChatSender {
     /** Resolves after the exact wire message is durable, independently of network delivery. */
     async enqueue(threadId, input) {
         const message = await this.persistOutgoing(threadId, input);
-        void this.retry(message.hash).catch(error => this.onError(error));
+        if (!this.closed && !this.closing && !this.withdrawn)
+            void this.retry(message.hash).catch(error => this.onError(error));
         return message;
     }
     /** Compatibility API: resolves only after transport delivery. */
@@ -58,23 +165,27 @@ export class DurableChatSender {
         const message = await this.persistOutgoing(threadId, input);
         return this.retry(message.hash);
     }
-    async persistOutgoing(threadId, input) {
-        await this.ready;
-        if (this.closed)
-            throw new Error("CHAT_SENDER_CLOSED");
-        const message = this.client.prepareChat(input.to, withChatTeam(input.body, this.identity.teamId), input.recipients);
-        if (message.from !== this.identity.profileId)
-            throw new Error("OUTGOING_MESSAGE_IDENTITY_MISMATCH");
-        const record = { scope: this.scope, threadId, hash: message.hash, message, status: "sending" };
-        await this.outbox.put(record);
-        if (this.closed)
-            throw new Error("CHAT_SENDER_CLOSED");
-        this.values.set(record.hash, record);
-        this.emit();
-        return message;
+    persistOutgoing(threadId, input) {
+        if (this.closed || this.closing || this.withdrawn)
+            return Promise.reject(new Error("OUTBOX_ACCESS_REVOKED"));
+        const pending = (async () => {
+            await this.ready;
+            await this.checkAccess();
+            const message = this.client.prepareChat(input.to, withChatTeam(input.body, this.identity.teamId), input.recipients);
+            if (message.from !== this.identity.profileId)
+                throw new Error("OUTGOING_MESSAGE_IDENTITY_MISMATCH");
+            const record = { scope: this.scope, threadId, hash: message.hash, message, status: "sending", accessVersion: this.version };
+            await this.withEpoch("rw", async () => { await this.outbox.put(record); });
+            await this.checkAccess();
+            this.values.set(record.hash, record);
+            this.emit();
+            return message;
+        })().finally(() => this.accepted.delete(pending));
+        this.accepted.add(pending);
+        return pending;
     }
     retry(hash) {
-        if (this.closed)
+        if (this.closed || this.closing || this.withdrawn)
             return Promise.reject(new Error("CHAT_SENDER_CLOSED"));
         const running = this.running.get(hash);
         if (running)
@@ -85,8 +196,8 @@ export class DurableChatSender {
     }
     async transmit(hash) {
         await this.ready;
-        const record = await this.outbox.get([this.scope, hash]);
-        if (!record || this.closed)
+        const record = await this.withEpoch("r", async () => this.outbox.get([this.scope, hash]));
+        if (!record || this.closed || this.withdrawn)
             throw new Error("OUTGOING_MESSAGE_UNAVAILABLE");
         if (record.status === "sent" || record.confirmed)
             return record.message;
@@ -96,6 +207,7 @@ export class DurableChatSender {
             if (!latest || latest.confirmed || latest.status === "sent")
                 return latest?.message ?? record.message;
         }
+        await this.checkAccess();
         if (this.values.get(hash)?.status !== "sending") {
             this.values.set(hash, sending);
             this.emit();
@@ -104,7 +216,7 @@ export class DurableChatSender {
             const message = await this.client.sendPrepared(record.message);
             const sent = { ...record, message, status: "sent" };
             const committed = await this.save(sent);
-            if (!this.closed) {
+            if (!this.closed && !this.withdrawn) {
                 if (committed?.confirmed || !committed)
                     this.values.delete(hash);
                 else
@@ -114,7 +226,7 @@ export class DurableChatSender {
             return message;
         }
         catch (error) {
-            if (!this.closed) {
+            if (!this.closed && !this.withdrawn) {
                 const failed = { ...record, status: "failed" };
                 const committed = await this.save(failed);
                 if (committed?.confirmed || committed?.status === "sent") {
@@ -132,7 +244,7 @@ export class DurableChatSender {
         }
     }
     async save(record) {
-        return this.db.transaction("rw", this.outbox, async () => {
+        return this.withEpoch("rw", async () => {
             const previous = await this.outbox.get([this.scope, record.hash]);
             if (!previous || previous.confirmed || previous.status === "sent")
                 return previous;
@@ -147,7 +259,7 @@ export class DurableChatSender {
         if (!hashes.length)
             return;
         await this.ready;
-        await this.db.transaction("rw", this.outbox, async () => {
+        await this.withEpoch("rw", async () => {
             const previous = await this.outbox.bulkGet(hashes.map(hash => [this.scope, hash]));
             const confirmed = previous.filter((record) => Boolean(record && !record.confirmed)).map(record => ({ ...record, status: "sent", confirmed: true }));
             if (confirmed.length)
@@ -161,12 +273,12 @@ export class DurableChatSender {
     }
     async resume() {
         await this.ready;
-        if (this.closed)
+        if (this.closed || this.closing || this.withdrawn)
             return;
         // Only interrupted, unconfirmed sends resume automatically; failed sends require retry.
         for (const record of this.values.values())
             if (record.status === "sending") {
-                if (this.closed)
+                if (this.closed || this.withdrawn)
                     return;
                 try {
                     await this.retry(record.hash);
@@ -177,11 +289,19 @@ export class DurableChatSender {
             }
     }
     async close() {
-        this.closed = true;
+        this.closing = true;
         this.offConnection();
         this.listeners.clear();
-        await this.ready;
-        await Promise.allSettled([...this.running.values()]);
-        this.db.close();
+        this.channel?.close();
+        try {
+            await this.ready;
+            await Promise.allSettled([...this.accepted, ...this.running.values(), ...(this.revoking ? [this.revoking] : [])]);
+        }
+        finally {
+            this.closed = true;
+            this.values.clear();
+            this.snapshots.clear();
+            this.db.close();
+        }
     }
 }

package/lib/runtime/messageClient.d.ts

@@ -36,6 +36,7 @@ export declare class MessageClient<T extends StoredMessage> {
     private options;
     private storage;
     private watches;
+    private accessListeners;
     private allListeners;
     private reads;
     private syncing;
@@ -55,7 +56,20 @@ export declare class MessageClient<T extends StoredMessage> {
     private pendingBytes;
     private pendingRecords;
     private legacyImports;
+    private revokingScope?;
+    private scopeReady?;
+    private scopeVersion;
+    private scopeAllowed;
+    private scopeDenied;
+    private enqueuing;
+    private ensureScope;
     constructor(options: MessageClientOptions<T>);
+    /** Shared guard for sibling caches; it never authorizes a denied old instance. */
+    subscribeAccessRevoked(listener: () => void): () => void;
+    scopeAccess(): Promise<{
+        version: number;
+        allowed: boolean;
+    }>;
     getSnapshot(thread: string): MessageSnapshot<T> | undefined;
     subscribe(thread: string, listener: () => void): () => void;
     subscribeAll(listener: (threadId: string) => void): () => void;
@@ -82,6 +96,8 @@ export declare class MessageClient<T extends StoredMessage> {
     }, limit?: number): Promise<MessageSnapshot<T>>;
     private fillWindow;
     private denyView;
+    private denyScope;
+    revokeScope(): Promise<number>;
     revoke(thread: string): Promise<void>;
-    close(): Promise<void>;
+    close(beforeDispose?: Promise<unknown>): Promise<void>;
 }