@droponair/sdk-js 0.26.0 → 0.28.0

package/CHANGELOG.md

@@ -1,5 +1,46 @@
 # Changelog
 
+## 0.28.0
+
+### Fixed
+
+- **A push token offered before the client connected was thrown away.** The push
+  service hands an app its device token at launch, always before a connection
+  exists, so `registerPushToken` refusing it there lost the token exactly when
+  every app first offers it, and push simply never arrived. The token is now held
+  and registered as soon as a connection exists. It is also re-registered on every
+  connect, because the relay ties a token to a session: after a reconnect or a
+  relay restart the device would otherwise be silently unreachable.
+
+### Notes
+
+- `registerPushToken` no longer rejects a call made before connecting. Existing
+  code that catches that error still compiles and simply stops seeing it.
+- `unregisterPushToken` drops the held token, so it is not re-registered later.
+
+## 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

@@ -207,6 +207,10 @@ client.onEvent(e => {
 
 Available since SDK `0.9.0`. Customers configure their own APNs / FCM / VAPID credentials in the dashboard. The platform delivers a push only when the sender attaches a `pushPayload` to a message and the recipient device has no live WebSocket session. See the per-product availability and limits on your dashboard's Subscription page.
 
+
+Register the token as soon as you have it. The SDK holds it until a connection
+exists and registers it then, and re-registers on every connect, so there is no
+need to wait for the client to connect or to retry yourself.
 ```typescript
 // iOS, after didRegisterForRemoteNotificationsWithDeviceToken
 await client.registerPushToken({ platform: 'APNS', token: deviceTokenHex });
@@ -359,6 +363,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

@@ -22,6 +22,11 @@ export declare class MessagingClient implements DropOnAirClient {
     private dropOnAirJwt;
     private currentUserId;
     private deviceId;
+    /**
+     * The push token this device last offered, held until a connection exists and
+     * re-sent on every connect. Cleared by `unregisterPushToken`.
+     */
+    private pendingPushRegistration;
     private rateLimited;
     private reconnectAttempt;
     private connectGeneration;
@@ -169,6 +174,8 @@ export declare class MessagingClient implements DropOnAirClient {
         token: string;
         voipToken?: string;
     }): Promise<void>;
+    /** Registers the held token, if there is one. Called on every connect. */
+    private sendPushRegistration;
     /**
      * Unregister this device's push notification token (e.g. on logout). Future
      * push fan-out for this (appId, userId, deviceId, platform) tuple is dropped.
@@ -374,6 +381,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

@@ -246,6 +246,11 @@ class MessagingClient {
         this.dropOnAirJwt = null;
         this.currentUserId = null;
         this.deviceId = null;
+        /**
+         * The push token this device last offered, held until a connection exists and
+         * re-sent on every connect. Cleared by `unregisterPushToken`.
+         */
+        this.pendingPushRegistration = null;
         this.rateLimited = false;
         this.reconnectAttempt = 0;
         // Monotonic id for each connect attempt. Transport callbacks (onOpen/onError/
@@ -650,18 +655,36 @@ class MessagingClient {
      * stored token and refreshes its lastSeenAt timestamp.
      */
     async registerPushToken(opts) {
-        if (!this.transport?.isOpen()) {
-            throw new Error('DropOnAir websocket is not connected');
-        }
         if (!opts.token || opts.token.trim().length === 0) {
             throw new Error('Push token must not be empty');
         }
-        const deviceId = this.deviceId ?? await this.getOrCreateDeviceId();
-        const frame = {
-            type: 'PUSH_REGISTER',
+        // The push service hands an app its token at startup, usually before a
+        // connection exists, so refusing the registration here would lose it exactly
+        // when every app first offers it. Hold it instead and send it on connect, and
+        // keep holding it: the relay ties a token to a session, so a reconnect or a
+        // relay restart has to re-register or the device goes quiet.
+        this.pendingPushRegistration = {
             platform: opts.platform,
             token: opts.token,
             voipToken: opts.voipToken ?? '',
+        };
+        if (!this.transport?.isOpen()) {
+            return;
+        }
+        await this.sendPushRegistration();
+    }
+    /** Registers the held token, if there is one. Called on every connect. */
+    async sendPushRegistration() {
+        const pending = this.pendingPushRegistration;
+        if (!pending || !this.transport?.isOpen()) {
+            return;
+        }
+        const deviceId = this.deviceId ?? await this.getOrCreateDeviceId();
+        const frame = {
+            type: 'PUSH_REGISTER',
+            platform: pending.platform,
+            token: pending.token,
+            voipToken: pending.voipToken,
             deviceId,
         };
         this.transport.send(this.codec.encodePushRegistrationFrame(frame));
@@ -671,6 +694,7 @@ class MessagingClient {
      * push fan-out for this (appId, userId, deviceId, platform) tuple is dropped.
      */
     async unregisterPushToken(opts) {
+        this.pendingPushRegistration = null;
         if (!this.transport?.isOpen()) {
             throw new Error('DropOnAir websocket is not connected');
         }
@@ -1779,6 +1803,12 @@ class MessagingClient {
                 if (this.dropOnAirJwt) {
                     this.scheduleProactiveTokenRefresh(this.dropOnAirJwt);
                 }
+                this.sendPushRegistration().catch((err) => {
+                    this.logError('push_registration_failed', { error: String(err) });
+                });
+                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 +1917,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 +2270,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.28.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.28.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.28.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",