@pmate/chat-sdk 0.11.8 → 0.12.0-next.0

package/lib/runtime/recordCache.js

@@ -0,0 +1,161 @@
+import { Dexie } from "dexie";
+import { WindowedTasks } from "./coalescer.js";
+/** In-memory control-event index backed by bounded asynchronous IndexedDB batches.
+ * Legacy storage is read only during open; the hot path never uses localStorage. */
+export class IndexedDbRecordCache {
+    options;
+    db;
+    records;
+    metadata;
+    values = new Map();
+    snapshotValue = [];
+    pending = new Map();
+    waiters = [];
+    tasks;
+    ready;
+    closed = false;
+    closing = false;
+    initialized = false;
+    running;
+    channel;
+    listeners = new Set();
+    constructor(options) {
+        this.options = options;
+        this.db = new Dexie(options.name ?? "pmate-chat-records", { indexedDB: options.indexedDB ?? globalThis.indexedDB, IDBKeyRange: globalThis.IDBKeyRange });
+        this.db.version(1).stores({ records: "[scope+id],scope", metadata: "scope" });
+        this.records = this.db.table("records");
+        this.metadata = this.db.table("metadata");
+        this.tasks = new WindowedTasks(16, error => options.onError?.(error));
+        if (typeof BroadcastChannel !== "undefined") {
+            this.channel = new BroadcastChannel(`pmate-chat-records:${options.scope}`);
+            this.channel.onmessage = () => this.tasks.schedule("reload", () => this.reload());
+        }
+    }
+    open(legacy) {
+        if (this.closed)
+            return Promise.reject(new Error("RECORD_CACHE_CLOSED"));
+        if (this.ready)
+            return this.ready;
+        this.ready = (async () => {
+            if (legacy && !(await this.metadata.get(this.options.scope))?.migrated) {
+                const previous = legacy();
+                // Idempotent batches: the completion marker is written only after every row.
+                for (let offset = 0; offset < previous.values.length; offset += 128)
+                    await this.write(previous.values.slice(offset, offset + 128));
+                await this.metadata.put({ scope: this.options.scope, migrated: true });
+                previous.clear();
+            }
+            await this.reload();
+            this.initialized = true;
+        })().catch(error => { this.ready = undefined; throw error; });
+        return this.ready;
+    }
+    snapshot() {
+        if (!this.initialized)
+            throw new Error("RECORD_CACHE_NOT_OPEN");
+        return this.snapshotValue;
+    }
+    subscribe(listener) { this.listeners.add(listener); return () => { this.listeners.delete(listener); }; }
+    async reload() {
+        const rows = await this.records.where("scope").equals(this.options.scope).toArray();
+        if (this.closed)
+            return;
+        let changed = false;
+        for (const row of rows) {
+            const old = this.values.get(row.id), next = this.options.merge(old, row.value);
+            if (JSON.stringify(old) !== JSON.stringify(next)) {
+                this.values.set(row.id, next);
+                changed = true;
+            }
+        }
+        if (changed) {
+            this.snapshotValue = [...this.values.values()];
+            this.listeners.forEach(listener => listener());
+        }
+    }
+    async upsert(incoming) {
+        if (this.closed || this.closing)
+            throw new Error("RECORD_CACHE_CLOSED");
+        if (!this.ready)
+            throw new Error("RECORD_CACHE_NOT_OPEN");
+        await this.ready;
+        if (this.closed || this.closing)
+            throw new Error("RECORD_CACHE_CLOSED");
+        if (incoming.length + this.pending.size > 4096)
+            throw new Error("RECORD_CACHE_BACKPRESSURE");
+        let changed = false;
+        for (const value of incoming) {
+            const key = this.options.key(value), old = this.values.get(key), next = this.options.merge(old, value);
+            if (JSON.stringify(old) === JSON.stringify(next))
+                continue;
+            this.values.set(key, next);
+            this.pending.set(key, next);
+            changed = true;
+        }
+        if (changed)
+            this.snapshotValue = [...this.values.values()];
+        if (!changed && !this.pending.size)
+            return;
+        const committed = new Promise((resolve, reject) => this.waiters.push({ resolve, reject }));
+        this.tasks.schedule("write", () => this.flush());
+        return committed;
+    }
+    async write(values) {
+        await this.db.transaction("rw", this.records, async () => {
+            const previous = await this.records.bulkGet(values.map(value => [this.options.scope, this.options.key(value)]));
+            const records = values.map((value, index) => ({ scope: this.options.scope, id: this.options.key(value), value: this.options.merge(previous[index]?.value, value) }));
+            const changed = records.filter((row, index) => JSON.stringify(previous[index]?.value) !== JSON.stringify(row.value));
+            if (changed.length)
+                await this.records.bulkPut(changed);
+        });
+    }
+    async flush() {
+        if (this.running) {
+            await this.running;
+            if (this.pending.size)
+                return this.flush();
+            return;
+        }
+        const task = this.runFlush().finally(() => { if (this.running === task)
+            this.running = undefined; });
+        this.running = task;
+        return task;
+    }
+    async runFlush() {
+        const values = [...this.pending.values()], waiters = this.waiters.splice(0);
+        this.pending.clear();
+        if (!values.length)
+            return;
+        try {
+            for (let offset = 0; offset < values.length; offset += 128)
+                await this.write(values.slice(offset, offset + 128));
+            await this.reload();
+            this.listeners.forEach(listener => listener());
+            this.channel?.postMessage("changed");
+            waiters.forEach(waiter => waiter.resolve());
+        }
+        catch (error) {
+            // Keep failed records dirty so a later operation can retry them.
+            for (const value of values) {
+                const key = this.options.key(value);
+                this.pending.set(key, this.options.merge(value, this.pending.get(key) ?? value));
+            }
+            waiters.forEach(waiter => waiter.reject(error));
+            throw error;
+        }
+    }
+    async close() {
+        this.closing = true;
+        await this.ready;
+        this.tasks.close();
+        try {
+            await this.flush();
+        }
+        finally {
+            this.closed = true;
+            this.channel?.close();
+            this.listeners.clear();
+            this.db.close();
+        }
+    }
+}

package/lib/runtime/socialReadClient.d.ts

@@ -6,6 +6,13 @@ export type SocialReadClientOptions = {
     hubHttpUrl?: string;
     fetch?: typeof fetch;
 };
+export type SocialMessagePage = {
+    messages: ChatReaderSocialMessage[];
+    checkpoint: string;
+    nextBefore: string | null;
+    hasMoreChanges: boolean;
+    resetRequired: boolean;
+};
 export type SocialGroup = {
     appId: string;
     groupId: string;
@@ -44,6 +51,13 @@ export declare class SocialReadClient {
         threadId: string;
         teamId?: string;
     }): Promise<ChatReaderSocialMessage[]>;
+    messagePage(input: {
+        threadId: string;
+        teamId?: string;
+        limit?: number;
+        before?: string;
+        after?: string;
+    }, signal?: AbortSignal): Promise<SocialMessagePage>;
     group(input: {
         groupId: string;
         teamId?: string;

package/lib/runtime/socialReadClient.js

@@ -24,6 +24,21 @@ export class SocialReadClient {
         this.requireTeam(input.teamId);
         return this.list("messages", { threadId: input.threadId, ...this.teamQuery(input.teamId) });
     }
+    async messagePage(input, signal) {
+        this.requireTeam(input.teamId);
+        const limit = input.limit ?? 100;
+        if (!Number.isSafeInteger(limit) || limit < 1 || limit > 500 || (input.before !== undefined && input.after !== undefined))
+            throw new SocialReadError(400, "INVALID_MESSAGE_PAGE");
+        const value = await this.request("messages", { threadId: input.threadId, ...this.teamQuery(input.teamId), limit: String(limit),
+            ...(input.before === undefined ? {} : { before: input.before }), ...(input.after === undefined ? {} : { after: input.after }) }, signal);
+        const cursor = (token) => typeof token === "string" && /^mp1:\d+:[0-9a-f]{64}$/.test(token);
+        if (!value || !Array.isArray(value.messages) || value.messages.length > limit || !cursor(value.checkpoint)
+            || (value.nextBefore !== null && !cursor(value.nextBefore)) || typeof value.hasMoreChanges !== "boolean" || typeof value.resetRequired !== "boolean"
+            || value.messages.some(row => row.appId !== this.options.appId || row.threadId !== input.threadId || row.teamId !== input.teamId || !row.messageId || !Number.isFinite(row.serverCreatedAt))
+            || (value.resetRequired && (value.messages.length || value.hasMoreChanges || value.nextBefore !== null)))
+            throw new SocialReadError(502, "INVALID_MESSAGE_PAGE_RESPONSE");
+        return value;
+    }
     group(input) {
         this.requireTeam(input.teamId);
         return this.request("group", { groupId: input.groupId, ...this.teamQuery(input.teamId) });
@@ -36,7 +51,7 @@ export class SocialReadClient {
         return teamId === undefined ? {} : { teamId };
     }
     requireTeam(teamId) {
-        if (this.options.appId === "pmate:hello" && !teamId)
+        if (this.options.appId === "pmate:merry" && !teamId)
             throw new SocialReadError(400, "TEAM_ID_REQUIRED");
     }
     async list(action, query) {
@@ -45,11 +60,11 @@ export class SocialReadClient {
             throw new SocialReadError(502, "INVALID_SOCIAL_READ_RESPONSE");
         return value;
     }
-    async request(action, query) {
+    async request(action, query, signal) {
         const search = new URLSearchParams({ ...query, appId: this.options.appId, profileId: this.options.profileId });
         const result = await (this.options.fetch ?? fetch)(`${(this.options.hubHttpUrl ?? "https://hub.pmate.chat").replace(/\/+$/, "")}/api/social/${action}?${search}`, {
             headers: { authorization: `Bearer ${this.options.token}`, accept: "application/json" },
-            cache: "no-store", redirect: "error", signal: AbortSignal.timeout(15_000),
+            cache: "no-store", redirect: "error", signal: signal ? AbortSignal.any([signal, AbortSignal.timeout(15_000)]) : AbortSignal.timeout(15_000),
         });
         const envelope = await result.json().catch(() => null);
         if (!result.ok || envelope?.success !== true || !Object.hasOwn(envelope, "data")) {

package/package.json

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