@signalapp/libsignal-client 0.53.0 → 0.54.0

package/dist/net.d.ts

@@ -80,25 +80,13 @@ export interface ChatServiceListener {
     onConnectionInterrupted(): void;
 }
 /**
- * Provides API methods to connect and communicate with the Chat Service over an authenticated channel.
+ * Provides API methods to connect and communicate with the Chat Service.
  * Before sending/receiving requests, a {@link #connect()} method must be called.
  * It's also important to call {@link #disconnect()} method when the instance is no longer needed.
  */
-export declare class AuthenticatedChatService {
-    private readonly asyncContext;
-    readonly chatService: Wrapper<Native.Chat>;
-    constructor(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, username: string, password: string, listener: ChatServiceListener);
-    /**
-     * Initiates termination of the underlying connection to the Chat Service. After the service is
-     * disconnected, it will not attempt to automatically reconnect until you call
-     * {@link #connect()}.
-     *
-     * Note: the same instance of `AuthenticatedChatService` can be reused after {@link #disconnect()} was
-     * called.
-     */
-    disconnect(): Promise<void>;
+export type ChatService = {
     /**
-     * Initiates establishing of the underlying authenticated connection to the Chat Service. Once the
+     * Initiates establishing of the underlying connection to the Chat Service. Once the
      * service is connected, all the requests will be using the established connection. Also, if the
      * connection is lost for any reason other than the call to {@link #disconnect()}, an automatic
      * reconnect attempt will be made.
@@ -113,7 +101,16 @@ export declare class AuthenticatedChatService {
         abortSignal?: AbortSignal;
     }): Promise<Native.ChatServiceDebugInfo>;
     /**
-     * Sends request to the Chat Service over an authenticated channel.
+     * Initiates termination of the underlying connection to the Chat Service. After the service is
+     * disconnected, it will not attempt to automatically reconnect until you call
+     * {@link #connect()}.
+     *
+     * Note: the same instance of `ChatService` can be reused after {@link #disconnect()} was
+     * called.
+     */
+    disconnect(): Promise<void>;
+    /**
+     * Sends request to the Chat Service.
      *
      * In addition to the response, an object containing debug information about the request flow is
      * returned.
@@ -125,7 +122,7 @@ export declare class AuthenticatedChatService {
         abortSignal?: AbortSignal;
     }): Promise<Native.ResponseAndDebugInfo>;
     /**
-     * Sends request to the Chat Service over an authenticated channel.
+     * Sends request to the Chat Service.
      *
      * @throws {ChatServiceInactive} if you haven't called {@link #connect()} (as a
      * rejection of the promise).
@@ -133,55 +130,39 @@ export declare class AuthenticatedChatService {
     fetch(chatRequest: ChatRequest, options?: {
         abortSignal?: AbortSignal;
     }): Promise<Native.ChatResponse>;
+};
+/**
+ * Provides API methods to connect and communicate with the Chat Service over an authenticated channel.
+ */
+export declare class AuthenticatedChatService implements ChatService {
+    private readonly asyncContext;
+    readonly chatService: Wrapper<Native.Chat>;
+    constructor(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager, username: string, password: string, receiveStories: boolean, listener: ChatServiceListener);
+    disconnect(): Promise<void>;
+    connect(options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatServiceDebugInfo>;
+    fetchAndDebug(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ResponseAndDebugInfo>;
+    fetch(chatRequest: ChatRequest, options?: {
+        abortSignal?: AbortSignal;
+    }): Promise<Native.ChatResponse>;
 }
 /**
  * Provides API methods to connect and communicate with the Chat Service over an unauthenticated channel.
- * Before sending requests, a {@link #connect()} method must be called.
- * It's also important to call {@link #disconnect()} method when the instance is no longer needed.
  */
-export declare class UnauthenticatedChatService {
+export declare class UnauthenticatedChatService implements ChatService {
     private readonly asyncContext;
     readonly chatService: Wrapper<Native.Chat>;
     constructor(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager);
-    /**
-     * Initiates termination of the underlying connection to the Chat Service. After the service is
-     * disconnected, it will not attempt to automatically reconnect until you call
-     * {@link #connect()}.
-     *
-     * Note: the same instance of `UnauthenticatedChatService` can be reused after {@link #disconnect()} was
-     * called.
-     */
     disconnect(): Promise<void>;
-    /**
-     * Initiates establishing of the underlying unauthenticated connection to the Chat Service. Once
-     * the service is connected, all the requests will be using the established connection. Also, if
-     * the connection is lost for any reason other than the call to {@link #disconnect()}, an
-     * automatic reconnect attempt will be made.
-     *
-     * @throws {AppExpiredError} if the current app version is too old (as judged by the server).
-     * @throws {LibSignalError} with other codes for other failures.
-     */
     connect(options?: {
         abortSignal?: AbortSignal;
     }): Promise<Native.ChatServiceDebugInfo>;
-    /**
-     * Sends request to the Chat Service over an unauthenticated channel.
-     *
-     * In addition to the response, an object containing debug information about the request flow is
-     * returned.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()} (as a
-     * rejection of the promise).
-     */
     fetchAndDebug(chatRequest: ChatRequest, options?: {
         abortSignal?: AbortSignal;
     }): Promise<Native.ResponseAndDebugInfo>;
-    /**
-     * Sends request to the Chat Service over an unauthenticated channel.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connect()} (as a
-     * rejection of the promise).
-     */
     fetch(chatRequest: ChatRequest, options?: {
         abortSignal?: AbortSignal;
     }): Promise<Native.ChatResponse>;
@@ -197,8 +178,13 @@ export declare class Net {
     constructor(env: Environment, userAgent: string);
     /**
      * Creates a new instance of {@link AuthenticatedChatService}.
+     *
+     * Note that created `AuthenticatedChatService` will hold a **non-garbage-collectable** reference to `listener`.
+     * If `listener` contains a strong reference to this ChatService (directly or indirectly), both objects will be kept
+     * alive even with no other references. If such reference cycle is created, it's the responsibility of the caller
+     * to eventually break it (either using a weak reference or by assigning over the strong reference).
      */
-    newAuthenticatedChatService(username: string, password: string, listener: ChatServiceListener): AuthenticatedChatService;
+    newAuthenticatedChatService(username: string, password: string, receiveStories: boolean, listener: ChatServiceListener): AuthenticatedChatService;
     /**
      * Creates a new instance of {@link UnauthenticatedChatService}.
      */

package/dist/net.js

@@ -61,13 +61,11 @@ class ChatServerMessageAck {
 exports.ChatServerMessageAck = ChatServerMessageAck;
 /**
  * Provides API methods to connect and communicate with the Chat Service over an authenticated channel.
- * Before sending/receiving requests, a {@link #connect()} method must be called.
- * It's also important to call {@link #disconnect()} method when the instance is no longer needed.
  */
 class AuthenticatedChatService {
-    constructor(asyncContext, connectionManager, username, password, listener) {
+    constructor(asyncContext, connectionManager, username, password, receiveStories, listener) {
         this.asyncContext = asyncContext;
-        this.chatService = newNativeHandle(Native.ChatService_new(connectionManager, username, password));
+        this.chatService = newNativeHandle(Native.ChatService_new(connectionManager, username, password, receiveStories));
         const nativeChatListener = {
             _incoming_message(envelope, timestamp, ack) {
                 listener.onIncomingMessage(envelope, timestamp, new ChatServerMessageAck(asyncContext, ack));
@@ -81,50 +79,15 @@ class AuthenticatedChatService {
         };
         Native.ChatServer_SetListener(asyncContext, this.chatService, nativeChatListener);
     }
-    /**
-     * Initiates termination of the underlying connection to the Chat Service. After the service is
-     * disconnected, it will not attempt to automatically reconnect until you call
-     * {@link #connect()}.
-     *
-     * Note: the same instance of `AuthenticatedChatService` can be reused after {@link #disconnect()} was
-     * called.
-     */
     disconnect() {
         return Native.ChatService_disconnect(this.asyncContext, this.chatService);
     }
-    /**
-     * Initiates establishing of the underlying authenticated connection to the Chat Service. Once the
-     * service is connected, all the requests will be using the established connection. Also, if the
-     * connection is lost for any reason other than the call to {@link #disconnect()}, an automatic
-     * reconnect attempt will be made.
-     *
-     * Calling this method will result in starting to accept incoming requests from the Chat Service.
-     *
-     * @throws {AppExpiredError} if the current app version is too old (as judged by the server).
-     * @throws {DeviceDelinkedError} if the current device has been delinked.
-     * @throws {LibSignalError} with other codes for other failures.
-     */
     connect(options) {
         return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_connect_auth(this.asyncContext, this.chatService));
     }
-    /**
-     * Sends request to the Chat Service over an authenticated channel.
-     *
-     * In addition to the response, an object containing debug information about the request flow is
-     * returned.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connect()} (as a
-     * rejection of the promise).
-     */
     fetchAndDebug(chatRequest, options) {
         return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_auth_send_and_debug(this.asyncContext, this.chatService, buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
     }
-    /**
-     * Sends request to the Chat Service over an authenticated channel.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connect()} (as a
-     * rejection of the promise).
-     */
     fetch(chatRequest, options) {
         return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_auth_send(this.asyncContext, this.chatService, buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
     }
@@ -132,55 +95,21 @@ class AuthenticatedChatService {
 exports.AuthenticatedChatService = AuthenticatedChatService;
 /**
  * Provides API methods to connect and communicate with the Chat Service over an unauthenticated channel.
- * Before sending requests, a {@link #connect()} method must be called.
- * It's also important to call {@link #disconnect()} method when the instance is no longer needed.
  */
 class UnauthenticatedChatService {
     constructor(asyncContext, connectionManager) {
         this.asyncContext = asyncContext;
-        this.chatService = newNativeHandle(Native.ChatService_new(connectionManager, '', ''));
+        this.chatService = newNativeHandle(Native.ChatService_new(connectionManager, '', '', false));
     }
-    /**
-     * Initiates termination of the underlying connection to the Chat Service. After the service is
-     * disconnected, it will not attempt to automatically reconnect until you call
-     * {@link #connect()}.
-     *
-     * Note: the same instance of `UnauthenticatedChatService` can be reused after {@link #disconnect()} was
-     * called.
-     */
     disconnect() {
         return Native.ChatService_disconnect(this.asyncContext, this.chatService);
     }
-    /**
-     * Initiates establishing of the underlying unauthenticated connection to the Chat Service. Once
-     * the service is connected, all the requests will be using the established connection. Also, if
-     * the connection is lost for any reason other than the call to {@link #disconnect()}, an
-     * automatic reconnect attempt will be made.
-     *
-     * @throws {AppExpiredError} if the current app version is too old (as judged by the server).
-     * @throws {LibSignalError} with other codes for other failures.
-     */
     connect(options) {
         return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_connect_unauth(this.asyncContext, this.chatService));
     }
-    /**
-     * Sends request to the Chat Service over an unauthenticated channel.
-     *
-     * In addition to the response, an object containing debug information about the request flow is
-     * returned.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()} (as a
-     * rejection of the promise).
-     */
     fetchAndDebug(chatRequest, options) {
         return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_unauth_send_and_debug(this.asyncContext, this.chatService, buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
     }
-    /**
-     * Sends request to the Chat Service over an unauthenticated channel.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connect()} (as a
-     * rejection of the promise).
-     */
     fetch(chatRequest, options) {
         return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_unauth_send(this.asyncContext, this.chatService, buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
     }
@@ -207,9 +136,14 @@ class Net {
     }
     /**
      * Creates a new instance of {@link AuthenticatedChatService}.
+     *
+     * Note that created `AuthenticatedChatService` will hold a **non-garbage-collectable** reference to `listener`.
+     * If `listener` contains a strong reference to this ChatService (directly or indirectly), both objects will be kept
+     * alive even with no other references. If such reference cycle is created, it's the responsibility of the caller
+     * to eventually break it (either using a weak reference or by assigning over the strong reference).
      */
-    newAuthenticatedChatService(username, password, listener) {
-        return new AuthenticatedChatService(this.asyncContext, this.connectionManager, username, password, listener);
+    newAuthenticatedChatService(username, password, receiveStories, listener) {
+        return new AuthenticatedChatService(this.asyncContext, this.connectionManager, username, password, receiveStories, listener);
     }
     /**
      * Creates a new instance of {@link UnauthenticatedChatService}.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signalapp/libsignal-client",
-  "version": "0.53.0",
+  "version": "0.54.0",
   "license": "AGPL-3.0-only",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",