@signalapp/libsignal-client 0.52.4 → 0.54.0

package/dist/net.d.ts

@@ -81,108 +81,93 @@ export interface ChatServiceListener {
 }
 /**
  * Provides API methods to connect and communicate with the Chat Service.
- * Before using either authenticated or unauthenticated channels,
- * a corresponding `connect*` method must be called.
+ * 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 ChatService {
-    private readonly asyncContext;
-    readonly chatService: Wrapper<Native.Chat>;
-    constructor(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager);
-    /**
-     * Sets the listener for server push messages on the authenticated connection.
-     *
-     * Note that this creates a **non-garbage-collectable** reference to `listener`. If `listener`
-     * contains a reference to this ChatService (directly or indirectly), both objects will be kept
-     * alive even with no other references. This may be fine if `listener` is a long-lived object
-     * anyway, but if not, make sure to eventually break the cycle, possibly by calling
-     * {@link #clearListener}.
-     */
-    setListener(listener: ChatServiceListener): void;
-    clearListener(): void;
-    /**
-     * 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 #connectAuthenticated()} and/or {@link #connectUnauthenticated()}.
-     *
-     * Note: the same instance of `ChatService` can be reused after `disconnect()` was
-     * called.
-     */
-    disconnect(): Promise<void>;
+export type 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.
-     */
-    connectUnauthenticated(options?: {
-        abortSignal?: AbortSignal;
-    }): Promise<Native.ChatServiceDebugInfo>;
-    /**
-     * 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.
      *
      * Calling this method will result in starting to accept incoming requests from the Chat Service.
-     * You should set a listener first using {@link #setListener()}.
      *
      * @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.
      */
-    connectAuthenticated(options?: {
+    connect(options?: {
         abortSignal?: AbortSignal;
     }): Promise<Native.ChatServiceDebugInfo>;
     /**
-     * Sends request to the Chat Service over an unauthenticated 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.
      *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()} (as a
+     * @throws {ChatServiceInactive} if you haven't called {@link #connect()} (as a
      * rejection of the promise).
      */
-    unauthenticatedFetchAndDebug(chatRequest: ChatRequest, options?: {
+    fetchAndDebug(chatRequest: ChatRequest, options?: {
         abortSignal?: AbortSignal;
     }): Promise<Native.ResponseAndDebugInfo>;
     /**
-     * Sends request to the Chat Service over an unauthenticated channel.
+     * Sends request to the Chat Service.
      *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()} (as a
+     * @throws {ChatServiceInactive} if you haven't called {@link #connect()} (as a
      * rejection of the promise).
      */
-    unauthenticatedFetch(chatRequest: ChatRequest, options?: {
+    fetch(chatRequest: ChatRequest, options?: {
         abortSignal?: AbortSignal;
     }): Promise<Native.ChatResponse>;
-    /**
-     * 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 #connectAuthenticated()} (as a
-     * rejection of the promise).
-     */
-    authenticatedFetchAndDebug(chatRequest: ChatRequest, options?: {
+};
+/**
+ * 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>;
-    /**
-     * Sends request to the Chat Service over an authenticated channel.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connectAuthenticated()} (as a
-     * rejection of the promise).
-     */
-    authenticatedFetch(chatRequest: ChatRequest, options?: {
+    fetch(chatRequest: ChatRequest, options?: {
         abortSignal?: AbortSignal;
     }): Promise<Native.ChatResponse>;
-    static buildHttpRequest(chatRequest: ChatRequest): {
-        _nativeHandle: Native.HttpRequest;
-    };
 }
+/**
+ * Provides API methods to connect and communicate with the Chat Service over an unauthenticated channel.
+ */
+export declare class UnauthenticatedChatService implements ChatService {
+    private readonly asyncContext;
+    readonly chatService: Wrapper<Native.Chat>;
+    constructor(asyncContext: TokioAsyncContext, connectionManager: ConnectionManager);
+    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>;
+}
+export declare function buildHttpRequest(chatRequest: ChatRequest): Wrapper<Native.HttpRequest>;
 export declare class Net {
     private readonly asyncContext;
     private readonly connectionManager;
@@ -192,9 +177,18 @@ export declare class Net {
     svr3: Svr3Client;
     constructor(env: Environment, userAgent: string);
     /**
-     * Creates a new instance of {@link ChatService}.
+     * 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, receiveStories: boolean, listener: ChatServiceListener): AuthenticatedChatService;
+    /**
+     * Creates a new instance of {@link UnauthenticatedChatService}.
      */
-    newChatService(): ChatService;
+    newUnauthenticatedChatService(): UnauthenticatedChatService;
     /**
      * Enables/disables IPv6 for all new connections (until changed).
      *

package/dist/net.js

@@ -4,7 +4,7 @@
 // SPDX-License-Identifier: AGPL-3.0-only
 //
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.RestoredSecret = exports.Net = exports.ChatService = exports.ChatServerMessageAck = exports.TokioAsyncContext = exports.newNativeHandle = exports.Environment = void 0;
+exports.RestoredSecret = exports.Net = exports.buildHttpRequest = exports.UnauthenticatedChatService = exports.AuthenticatedChatService = exports.ChatServerMessageAck = exports.TokioAsyncContext = exports.newNativeHandle = exports.Environment = void 0;
 const Native = require("../Native");
 const Address_1 = require("./Address");
 const node_buffer_1 = require("node:buffer");
@@ -60,27 +60,12 @@ class ChatServerMessageAck {
 }
 exports.ChatServerMessageAck = ChatServerMessageAck;
 /**
- * Provides API methods to connect and communicate with the Chat Service.
- * Before using either authenticated or unauthenticated channels,
- * a corresponding `connect*` method must be called.
- * It's also important to call {@link #disconnect()} method when the instance is no longer needed.
+ * Provides API methods to connect and communicate with the Chat Service over an authenticated channel.
  */
-class ChatService {
-    constructor(asyncContext, connectionManager) {
+class AuthenticatedChatService {
+    constructor(asyncContext, connectionManager, username, password, receiveStories, listener) {
         this.asyncContext = asyncContext;
-        this.chatService = newNativeHandle(Native.ChatService_new(connectionManager, '', ''));
-    }
-    /**
-     * Sets the listener for server push messages on the authenticated connection.
-     *
-     * Note that this creates a **non-garbage-collectable** reference to `listener`. If `listener`
-     * contains a reference to this ChatService (directly or indirectly), both objects will be kept
-     * alive even with no other references. This may be fine if `listener` is a long-lived object
-     * anyway, but if not, make sure to eventually break the cycle, possibly by calling
-     * {@link #clearListener}.
-     */
-    setListener(listener) {
-        const asyncContext = this.asyncContext;
+        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));
@@ -94,104 +79,55 @@ class ChatService {
         };
         Native.ChatServer_SetListener(asyncContext, this.chatService, nativeChatListener);
     }
-    clearListener() {
-        Native.ChatServer_SetListener(this.asyncContext, this.chatService, null);
-    }
-    /**
-     * 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 #connectAuthenticated()} and/or {@link #connectUnauthenticated()}.
-     *
-     * Note: the same instance of `ChatService` can be reused after `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.
-     */
-    connectUnauthenticated(options) {
-        return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_connect_unauth(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.
-     * You should set a listener first using {@link #setListener()}.
-     *
-     * @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.
-     */
-    connectAuthenticated(options) {
+    connect(options) {
         return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_connect_auth(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).
-     */
-    unauthenticatedFetchAndDebug(chatRequest, options) {
-        return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_unauth_send_and_debug(this.asyncContext, this.chatService, ChatService.buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
+    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 unauthenticated channel.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connectUnauthenticated()} (as a
-     * rejection of the promise).
-     */
-    unauthenticatedFetch(chatRequest, options) {
-        return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_unauth_send(this.asyncContext, this.chatService, ChatService.buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
+    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));
     }
-    /**
-     * 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 #connectAuthenticated()} (as a
-     * rejection of the promise).
-     */
-    authenticatedFetchAndDebug(chatRequest, options) {
-        return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_auth_send_and_debug(this.asyncContext, this.chatService, ChatService.buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
+}
+exports.AuthenticatedChatService = AuthenticatedChatService;
+/**
+ * Provides API methods to connect and communicate with the Chat Service over an unauthenticated channel.
+ */
+class UnauthenticatedChatService {
+    constructor(asyncContext, connectionManager) {
+        this.asyncContext = asyncContext;
+        this.chatService = newNativeHandle(Native.ChatService_new(connectionManager, '', '', false));
     }
-    /**
-     * Sends request to the Chat Service over an authenticated channel.
-     *
-     * @throws {ChatServiceInactive} if you haven't called {@link #connectAuthenticated()} (as a
-     * rejection of the promise).
-     */
-    authenticatedFetch(chatRequest, options) {
-        return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_auth_send(this.asyncContext, this.chatService, ChatService.buildHttpRequest(chatRequest), chatRequest.timeoutMillis ?? DEFAULT_CHAT_REQUEST_TIMEOUT_MILLIS));
+    disconnect() {
+        return Native.ChatService_disconnect(this.asyncContext, this.chatService);
     }
-    static buildHttpRequest(chatRequest) {
-        const { verb, path, body, headers } = chatRequest;
-        const bodyBuffer = body !== undefined ? node_buffer_1.Buffer.from(body) : null;
-        const httpRequest = {
-            _nativeHandle: Native.HttpRequest_new(verb, path, bodyBuffer),
-        };
-        headers.forEach((header) => {
-            const [name, value] = header;
-            Native.HttpRequest_add_header(httpRequest, name, value);
-        });
-        return httpRequest;
+    connect(options) {
+        return this.asyncContext.makeCancellable(options?.abortSignal, Native.ChatService_connect_unauth(this.asyncContext, this.chatService));
+    }
+    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));
+    }
+    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));
     }
 }
-exports.ChatService = ChatService;
+exports.UnauthenticatedChatService = UnauthenticatedChatService;
+function buildHttpRequest(chatRequest) {
+    const { verb, path, body, headers } = chatRequest;
+    const bodyBuffer = body !== undefined ? node_buffer_1.Buffer.from(body) : null;
+    const httpRequest = {
+        _nativeHandle: Native.HttpRequest_new(verb, path, bodyBuffer),
+    };
+    headers.forEach((header) => {
+        const [name, value] = header;
+        Native.HttpRequest_add_header(httpRequest, name, value);
+    });
+    return httpRequest;
+}
+exports.buildHttpRequest = buildHttpRequest;
 class Net {
     constructor(env, userAgent) {
         this.asyncContext = new TokioAsyncContext(Native.TokioAsyncContext_new());
@@ -199,10 +135,21 @@ class Net {
         this.svr3 = new Svr3ClientImpl(this.asyncContext, this.connectionManager);
     }
     /**
-     * Creates a new instance of {@link ChatService}.
+     * 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, receiveStories, listener) {
+        return new AuthenticatedChatService(this.asyncContext, this.connectionManager, username, password, receiveStories, listener);
+    }
+    /**
+     * Creates a new instance of {@link UnauthenticatedChatService}.
      */
-    newChatService() {
-        return new ChatService(this.asyncContext, this.connectionManager);
+    newUnauthenticatedChatService() {
+        return new UnauthenticatedChatService(this.asyncContext, this.connectionManager);
     }
     /**
      * Enables/disables IPv6 for all new connections (until changed).

package/package.json

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