@droponair/sdk-js 0.26.0 → 0.27.0

package/CHANGELOG.md

@@ -1,5 +1,28 @@
 # Changelog
 
+## 0.27.0
+
+### Added
+
+- **Group messages sent while you were offline are now delivered.** On connect the SDK
+  drains anything it missed and hands each message to `onGroupMessage` exactly as if it
+  had arrived live, so a message sent to a closed or disconnected app is no longer lost.
+  Nothing to call: it happens on every connect, beside the one-to-one drain.
+- **Delivery receipts on group messages name the member they are about.** The group
+  acknowledgement now carries `memberUserId`. A group message has many recipients, so
+  delivery is a set rather than a flag, and the platform hands you the set rather than
+  collapsing it: show a single tick once everyone has it, or a read-by list, whichever
+  your app wants. `memberUserId` is empty on `SERVER_RECEIVED`, which is about the relay
+  rather than any member.
+
+### Notes
+
+- Group messages were always stored for absent members but nothing ever returned them,
+  so they were silently lost and `DELIVERED` could never arrive. Both are fixed.
+- Additive and backward compatible. An older SDK simply never asks for the missed
+  messages and behaves exactly as it does today; a relay that predates this answers
+  404 and the SDK treats that as nothing to catch up on.
+
 ## 0.26.0
 
 ### Added

package/README.md

@@ -359,6 +359,17 @@ client.onMessage(async (msg) => {
 | `sendCleartextGroupMessage(groupId, plaintext)` | `Promise<{ messageId }>` | Send a plaintext (non-encrypted) group message; server fans out to every other member. |
 | `onGroupMessage(callback)` | `() => void` | Listen for group messages |
 
+**Group delivery is per member.** A group message has many recipients, so the platform
+reports delivery as a set rather than a single flag and leaves the presentation to you.
+`DELIVERED` and `SEEN` arrive as events whose `metadata` carries `messageId`, `groupId`
+and `memberUserId`, the member the acknowledgement is about. Show one tick once the set
+covers the group, or a read-by list, whichever suits your app. `memberUserId` is absent
+on `SERVER_RECEIVED`, which is about the relay rather than any member.
+
+**Group messages missed while offline arrive on connect.** Anything sent while the app
+was closed or disconnected is drained automatically when it reconnects and delivered
+through `onGroupMessage` just like a live message. There is nothing to call.
+
 ### 1-to-1 Calls
 
 | Method | Returns | Description |

package/dist/core/messaging-client.d.ts

@@ -374,6 +374,14 @@ export declare class MessagingClient implements DropOnAirClient {
      */
     private fetchMyOtherDeviceKeys;
     private ensureIdentityPublished;
+    /**
+     * Group messages that arrived while this device had no connection.
+     *
+     * Without this a group message is delivered only to sessions that happen to be
+     * live at that instant and is unreachable afterwards, so anyone closed loses it.
+     * Fetching is also what tells the sender the message reached this member.
+     */
+    private fetchAndProcessOfflineGroupMessages;
     private fetchAndProcessOfflineMessages;
     private getValidDropOnAirJwt;
     private extractSubject;

package/dist/core/messaging-client.js

@@ -1779,6 +1779,9 @@ class MessagingClient {
                 if (this.dropOnAirJwt) {
                     this.scheduleProactiveTokenRefresh(this.dropOnAirJwt);
                 }
+                this.fetchAndProcessOfflineGroupMessages().catch((err) => {
+                    this.logError('group_offline_fetch_failed', { error: String(err) });
+                });
                 this.fetchAndProcessOfflineMessages().catch((err) => {
                     this.logError('offline_fetch_failed', { error: String(err?.message ?? err) });
                     this.emitEvent({ type: 'ERROR', reason: 'OFFLINE_FETCH_FAILED' });
@@ -1887,7 +1890,14 @@ class MessagingClient {
                 if (frame.kind === 'groupAck') {
                     this.emitEvent({
                         type: frame.data.type,
-                        metadata: JSON.stringify({ messageId: frame.data.messageId, groupId: frame.data.groupId }),
+                        // memberUserId says which member this concerns. A group message has
+                        // many recipients, so an acknowledgement without it cannot be turned
+                        // into anything more useful than a single tick.
+                        metadata: JSON.stringify({
+                            messageId: frame.data.messageId,
+                            groupId: frame.data.groupId,
+                            ...(frame.data.memberUserId ? { memberUserId: frame.data.memberUserId } : {}),
+                        }),
                     });
                     return;
                 }
@@ -2233,6 +2243,58 @@ class MessagingClient {
         }
         this.log('key_publish_ok', { url, status: response.status, deviceId: myDeviceId });
     }
+    /**
+     * Group messages that arrived while this device had no connection.
+     *
+     * Without this a group message is delivered only to sessions that happen to be
+     * live at that instant and is unreachable afterwards, so anyone closed loses it.
+     * Fetching is also what tells the sender the message reached this member.
+     */
+    async fetchAndProcessOfflineGroupMessages() {
+        const jwt = await this.getValidDropOnAirJwt(false);
+        let page = 0;
+        let totalPages = 1;
+        let totalProcessed = 0;
+        this.log('group_offline_fetch_started', { httpUrl: this.httpUrl, pageSize: 100 });
+        while (page < totalPages) {
+            const response = await this.fetchFn(`${this.httpUrl}/v1/groups/messages/offline?page=${page}&size=100`, {
+                method: 'GET',
+                headers: { Authorization: `Bearer ${jwt}`, 'Content-Type': 'application/json' },
+            });
+            if (!response.ok) {
+                // A relay that predates this endpoint answers 404. That is not an error
+                // worth surfacing: the SDK simply has nothing to catch up on there.
+                if (response.status !== 404) {
+                    this.logError('group_offline_fetch_page_failed', { page, status: response.status });
+                }
+                return;
+            }
+            const body = await response.json();
+            totalPages = body.totalPages ?? 0;
+            for (const offline of body.messages) {
+                const notification = {
+                    messageId: offline.messageId,
+                    groupId: offline.groupId,
+                    fromUserId: offline.fromUserId,
+                    timestamp: new Date(offline.createdAt).getTime(),
+                    encryptionType: offline.encryptionType === 'CLEARTEXT' ? 1 : 0,
+                    plaintextPayload: offline.plaintextPayload,
+                    senderDeviceId: offline.senderDeviceId,
+                    devicePayloads: (offline.devicePayloads ?? []).map(dp => ({
+                        deviceId: dp.deviceId,
+                        encryptedPayload: (0, bytes_1.fromBase64)(dp.encryptedPayloadBase64),
+                        senderPublicKey: (0, bytes_1.fromBase64)(dp.senderPublicKeyBase64),
+                    })),
+                };
+                // The same path a live message takes, so decryption, de-duplication and
+                // the callback behave identically.
+                await this.handleIncomingGroupMessage(notification);
+                totalProcessed += 1;
+            }
+            page += 1;
+        }
+        this.log('group_offline_fetch_done', { totalProcessed });
+    }
     async fetchAndProcessOfflineMessages() {
         const jwt = await this.getValidDropOnAirJwt(false);
         let page = 0;

package/dist/transport/protobuf-codec.d.ts

@@ -133,6 +133,12 @@ export interface WireGroupAck {
     messageId: string;
     groupId: string;
     type: string;
+    /**
+     * Which member the acknowledgement is about. A group message has many
+     * recipients, so the useful fact is which of them has it. Empty on
+     * SERVER_RECEIVED, which concerns the relay rather than any member.
+     */
+    memberUserId?: string;
 }
 export interface WireGroupCallFrame {
     type: string;

package/dist/transport/protobuf-codec.js

@@ -193,7 +193,8 @@ const GroupMessageNotificationType = new protobuf.Type('GroupMessageNotification
 const GroupAckType = new protobuf.Type('GroupAck')
     .add(new protobuf.Field('messageId', 1, 'string'))
     .add(new protobuf.Field('groupId', 2, 'string'))
-    .add(new protobuf.Field('type', 3, 'string'));
+    .add(new protobuf.Field('type', 3, 'string'))
+    .add(new protobuf.Field('memberUserId', 4, 'string'));
 const GroupCallFrameType = new protobuf.Type('GroupCallFrame')
     .add(new protobuf.Field('type', 1, 'string'))
     .add(new protobuf.Field('callId', 2, 'string'))

package/dist/version.d.ts

@@ -7,7 +7,7 @@
  *   MINOR, additive feature (e.g. multi-device payloads, new call event type)
  *   PATCH, bug-fix / perf improvement with no wire or API change
  */
-export declare const SDK_VERSION = "0.26.0";
+export declare const SDK_VERSION = "0.27.0";
 /**
  * Binary encrypted-payload format version.
  * Included as the first byte of every encrypted payload so receivers can
@@ -19,4 +19,4 @@ export declare const PAYLOAD_FORMAT_VERSION = 1;
  * Increment when adding required proto fields or changing frame semantics.
  * The server advertises its supported range via GET /api/info.
  */
-export declare const PROTOCOL_VERSION = 6;
+export declare const PROTOCOL_VERSION = 7;

package/dist/version.js

@@ -10,7 +10,7 @@ exports.PROTOCOL_VERSION = exports.PAYLOAD_FORMAT_VERSION = exports.SDK_VERSION
  *   MINOR, additive feature (e.g. multi-device payloads, new call event type)
  *   PATCH, bug-fix / perf improvement with no wire or API change
  */
-exports.SDK_VERSION = '0.26.0';
+exports.SDK_VERSION = '0.27.0';
 /**
  * Binary encrypted-payload format version.
  * Included as the first byte of every encrypted payload so receivers can
@@ -22,4 +22,4 @@ exports.PAYLOAD_FORMAT_VERSION = 1;
  * Increment when adding required proto fields or changing frame semantics.
  * The server advertises its supported range via GET /api/info.
  */
-exports.PROTOCOL_VERSION = 6;
+exports.PROTOCOL_VERSION = 7;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@droponair/sdk-js",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "End-to-end encrypted messaging, voice and video calling SDK. The relay never sees your keys or message content.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",