@pmate/chat-sdk 0.12.0-next.59 → 0.12.0-next.60

package/lib/runtime/responseCache.js

@@ -30,6 +30,9 @@ export class IndexedDbResponseCache {
     constructor(scope, options = {}) {
         this.scope = scope;
         this.options = options;
+        for (const [value, max] of [[options.recordBytes ?? 65536, 1048576], [options.entries ?? 256, 256], [options.batchRecords ?? 128, 128]])
+            if (!Number.isSafeInteger(value) || value < 1 || value > max)
+                throw new Error("INVALID_RESPONSE_CACHE_LIMIT");
         this.db = new Dexie(options.name ?? "pmate-chat-response-windows", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
         this.db.version(1).stores({ windows: "[scope+key],scope", epochs: "scope" });
         this.rows = this.db.table("windows");
@@ -72,15 +75,30 @@ export class IndexedDbResponseCache {
             return { epoch, cached: row?.epoch === epoch ? { value: row.value, time: row.time } : undefined };
         });
     }
-    write(key, value, epoch) {
+    /** Key-only callers can share one bounded metadata read transaction. */
+    async readMany(keys) {
+        if (this.closed)
+            throw new Error("RESPONSE_CACHE_CLOSED");
+        if (keys.length > 128)
+            throw new Error("RESPONSE_CACHE_SELECTION_TOO_LARGE");
+        await this.synchronizeAccess();
+        return this.db.transaction("r", this.rows, this.epochs, async () => {
+            const epoch = (await this.epochs.get(this.scope))?.epoch ?? 0, unique = [...new Set(keys)];
+            const rows = await this.rows.bulkGet(unique.map(key => [this.scope, key]));
+            return new Map(unique.map((key, index) => { const row = rows[index]; return [key, { epoch, cached: row?.epoch === epoch ? { value: row.value, time: row.time } : undefined }]; }));
+        });
+    }
+    write(key, value, epoch, expectedRevision) {
         if (this.closed)
             return Promise.reject(new Error("RESPONSE_CACHE_CLOSED"));
+        if (expectedRevision !== undefined && !this.options.revision)
+            return Promise.reject(new Error("RESPONSE_CACHE_REVISION_UNAVAILABLE"));
         const copy = structuredClone(value), bytes = new TextEncoder().encode(JSON.stringify(copy)).byteLength;
         // Count in-flight data as well as queued data; requests cannot create an
         // unbounded backlog while IndexedDB is blocked by another tab.
-        if (bytes > 65536 || this.pending.length >= 128 || this.pending.reduce((n, w) => n + w.row.bytes, 0) + bytes > 1048576)
+        if (bytes > (this.options.recordBytes ?? 65536) || this.pending.length >= 128 || this.pending.reduce((n, w) => n + w.row.bytes, 0) + bytes > 1048576)
             return Promise.reject(new Error("RESPONSE_CACHE_BACKPRESSURE"));
-        const promise = new Promise((resolve, reject) => this.pending.push({ row: { scope: this.scope, key, epoch, time: Date.now(), bytes, value: copy }, resolve, reject }));
+        const promise = new Promise((resolve, reject) => this.pending.push({ row: { scope: this.scope, key, epoch, time: Date.now(), bytes, value: copy }, expectedRevision, resolve, reject }));
         this.tasks.schedule("write", () => this.flush());
         return promise;
     }
@@ -122,35 +140,74 @@ export class IndexedDbResponseCache {
                 return this.flush();
             return;
         }
-        const batch = [...this.pending];
-        if (!batch.length)
+        if (!this.pending.length)
             return;
         const task = (async () => {
-            try {
-                await this.synchronizeAccess();
-                const accepted = await this.db.transaction("rw", this.rows, this.epochs, async () => {
-                    const epoch = (await this.epochs.get(this.scope))?.epoch ?? 0;
-                    const valid = batch.filter(write => write.row.epoch === epoch);
-                    const unique = new Map(valid.map(write => [write.row.key, write.row]));
-                    await this.rows.bulkPut([...unique.values()]);
-                    const stored = await this.rows.where("scope").equals(this.scope).toArray();
-                    stored.sort((a, b) => b.time - a.time || a.key.localeCompare(b.key));
-                    let bytes = 0;
-                    const evicted = [];
-                    stored.forEach((row, index) => { bytes += row.bytes; if (index >= 256 || bytes > 1048576)
-                        evicted.push([this.scope, row.key]); });
-                    await this.rows.bulkDelete(evicted);
-                    return new Set(valid);
-                });
-                batch.forEach(write => accepted.has(write) ? write.resolve() : write.reject(new Error("RESPONSE_CACHE_INVALIDATED")));
-            }
-            catch (error) {
-                batch.forEach(write => write.reject(error));
-                throw error;
-            }
-            finally {
-                this.pending.splice(0, batch.length);
+            let failed = false, failure;
+            // Each batch commits and resolves independently. A configured smaller
+            // batch still drains all accepted requests, including during close.
+            while (this.pending.length) {
+                const batch = this.pending.slice(0, this.options.batchRecords ?? 128);
+                try {
+                    await this.synchronizeAccess();
+                    const outcome = await this.db.transaction("rw", this.rows, this.epochs, async () => {
+                        const epoch = (await this.epochs.get(this.scope))?.epoch ?? 0;
+                        const valid = batch.filter(write => write.row.epoch === epoch);
+                        const conditional = valid.filter(write => write.expectedRevision !== undefined);
+                        const keys = [...new Set(conditional.map(write => write.row.key))];
+                        const current = conditional.length ? await this.rows.bulkGet(keys.map(key => [this.scope, key])) : [];
+                        const projected = new Map(keys.map((key, index) => [key, current[index]?.epoch === epoch ? current[index] : undefined]));
+                        const accepted = new Set(), changed = new Set(), unique = new Map();
+                        for (const write of valid) {
+                            if (write.expectedRevision !== undefined) {
+                                const previous = projected.get(write.row.key);
+                                const revision = previous ? this.options.revision(previous.value) : null;
+                                if (revision !== write.expectedRevision) {
+                                    // Another document may have already committed this exact
+                                    // revision; it is an idempotent success, never an overwrite.
+                                    if (revision === this.options.revision(write.row.value) && JSON.stringify(previous.value) === JSON.stringify(write.row.value))
+                                        accepted.add(write);
+                                    else
+                                        changed.add(write);
+                                    continue;
+                                }
+                            }
+                            unique.set(write.row.key, write.row);
+                            projected.set(write.row.key, write.row);
+                            accepted.add(write);
+                        }
+                        if (unique.size) {
+                            await this.rows.bulkPut([...unique.values()]);
+                            const stored = await this.rows.where("scope").equals(this.scope).toArray();
+                            stored.sort((a, b) => b.time - a.time || a.key.localeCompare(b.key));
+                            let bytes = 0;
+                            const evicted = [];
+                            stored.forEach((row, index) => { bytes += row.bytes; if (index >= (this.options.entries ?? 256) || bytes > 1048576)
+                                evicted.push([this.scope, row.key]); });
+                            if (evicted.length)
+                                await this.rows.bulkDelete(evicted);
+                        }
+                        return { accepted, changed };
+                    });
+                    for (const write of batch) {
+                        if (outcome.accepted.has(write))
+                            write.resolve();
+                        else
+                            write.reject(new Error(outcome.changed.has(write) ? "RESPONSE_CACHE_CHANGED" : "RESPONSE_CACHE_INVALIDATED"));
+                    }
+                }
+                catch (error) {
+                    batch.forEach(write => write.reject(error));
+                    if (!failed)
+                        failure = error;
+                    failed = true;
+                }
+                finally {
+                    this.pending.splice(0, batch.length);
+                }
             }
+            if (failed)
+                throw failure;
         })().finally(() => { if (this.running === task)
             this.running = undefined; });
         this.running = task;

package/lib/runtime/socialReadClient.d.ts

@@ -22,6 +22,7 @@ export type SocialGroup = {
     title: string;
     avatar?: string | null;
     revision: string;
+    versionNumber?: number;
 };
 export type SocialRelationship = {
     appId: string;
@@ -62,7 +63,7 @@ export declare class SocialReadClient {
     group(input: {
         groupId: string;
         teamId?: string;
-    }): Promise<SocialGroup>;
+    }, signal?: AbortSignal): Promise<SocialGroup>;
     relationship(input: {
         peerId: string;
         teamId?: string;

package/lib/runtime/socialReadClient.js

@@ -43,9 +43,9 @@ export class SocialReadClient {
             throw new SocialReadError(502, "INVALID_MESSAGE_LOOKUP_RESPONSE");
         return value;
     }
-    group(input) {
+    group(input, signal) {
         this.requireTeam(input.teamId);
-        return this.request("group", { groupId: input.groupId, ...this.teamQuery(input.teamId) });
+        return this.request("group", { groupId: input.groupId, ...this.teamQuery(input.teamId) }, signal);
     }
     relationship(input) {
         this.requireTeam(input.teamId);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pmate/chat-sdk",
-  "version": "0.12.0-next.59",
+  "version": "0.12.0-next.60",
   "description": "Cross-platform PMate chat input components, voice input primitives, and ASR helpers",
   "type": "module",
   "main": "./lib/index.js",