centrifuge 4.0.1 → 5.0.0-beta.0

package/README.md

@@ -305,6 +305,10 @@ centrifuge.presenceStats("channel").then(function(resp) {
 
 Returns a Promise which will be resolved upon connection establishement (i.e. when Client goes to `connected` state).
 
+#### setToken method
+
+`setToken` may be useful to dynamically change the connection token. For example when you need to implement login/logout workflow. See an example in [blog post](https://centrifugal.dev/blog/2023/06/29/centrifugo-v5-released#token-behaviour-adjustments-in-sdks).
+
 #### error event
 
 To listen asynchronous error happening internally while Centrifuge client works you can set an `error` handler:
@@ -333,7 +337,7 @@ In case of Centrifugo on a server side this may be a JSON Web Token - see [authe
 
 **Connection token must come to the frontend from application backend - i.e. must be generated on the backend side**. The way to deliver token to the application frontend is up to the developer. Usually you can pass it in template rendering context or issue a separate call to request a connection token from the backend.
 
-If the token sets connection expiration then the client SDK will keep the token refreshed. It does this by calling a special callback function. This callback must return a new token. If a new token with updated connection expiration is returned from callback then it's sent to Centrifugo. If your callback returns an empty string – this means the user has no permission to connect to Centrifugo and the Client will move to a disconnected state. In case of error returned by your callback SDK will retry the operation after some jittered time.
+If the token sets connection expiration then the client SDK will keep the token refreshed. It does this by calling a special callback function. This callback must return a new token. If a new token with updated connection expiration is returned from callback then it's sent to Centrifugo. In case of error returned by your callback SDK will retry the operation after some jittered time. You can throw a special error (`throw new Centrifuge.UnauthorizedError();`) from `getToken` function to move the client into disconnected state (for example, when there is no permission to connect anymore).
 
 An example of possible `getToken` function implementation:
 

package/build/centrifuge.d.ts

@@ -1,169 +1,158 @@
-import { Subscription } from './subscription';
-import { State, Options, ClientEvents, TypedEventEmitter, RpcResult, SubscriptionOptions, HistoryOptions, HistoryResult, PublishResult, PresenceResult, PresenceStatsResult, TransportEndpoint } from './types';
-export declare class UnauthorizedError extends Error {
-    constructor(message: any);
-}
-declare const Centrifuge_base: new () => TypedEventEmitter<ClientEvents>;
-/** Centrifuge is a Centrifuge/Centrifugo bidirectional client. */
-export declare class Centrifuge extends Centrifuge_base {
-    state: State;
-    private _endpoint;
-    private _emulation;
-    private _transports;
-    private _currentTransportIndex;
-    private _triedAllTransports;
-    private _transportWasOpen;
-    private _transport?;
-    private _transportId;
-    private _deviceWentOffline;
-    private _transportClosed;
-    private _reconnecting;
-    private _reconnectTimeout?;
-    private _reconnectAttempts;
-    private _client;
-    private _session;
-    private _node;
-    private _subs;
-    private _serverSubs;
-    private _commandId;
-    private _commands;
-    private _batching;
-    private _refreshRequired;
-    private _refreshTimeout?;
-    private _callbacks;
-    private _token;
-    private _data;
-    private _dispatchPromise;
-    private _serverPing;
-    private _serverPingTimeout?;
-    private _sendPong;
-    private _promises;
-    private _promiseId;
-    private _networkEventsSet;
-    private _debugEnabled;
-    private _config;
-    protected _encoder: any;
-    protected _decoder: any;
-    static State: {
-        Disconnected: string;
-        Connecting: string;
-        Connected: string;
-    };
-    static SubscriptionState: {
-        Unsubscribed: string;
-        Subscribing: string;
-        Subscribed: string;
-    };
-    static UnauthorizedError: any;
-    /** Constructs Centrifuge client. Call connect() method to start connecting. */
-    constructor(endpoint: string | Array<TransportEndpoint>, options?: Partial<Options>);
-    /** newSubscription allocates new Subscription to a channel. Since server only allows
-     * one subscription per channel per client this method throws if client already has
-     * channel subscription in internal registry.
-     * */
-    newSubscription(channel: string, options?: Partial<SubscriptionOptions>): Subscription;
-    /** getSubscription returns Subscription if it's registered in the internal
-     * registry or null. */
-    getSubscription(channel: string): Subscription | null;
-    /** removeSubscription allows removing Subcription from the internal registry. Subscrption
-     * must be in unsubscribed state. */
-    removeSubscription(sub: Subscription | null): void;
-    /** Get a map with all current client-side subscriptions. */
-    subscriptions(): Record<string, Subscription>;
-    /** ready returns a Promise which resolves upon client goes to Connected
-     * state and rejects in case of client goes to Disconnected or Failed state.
-     * Users can provide optional timeout in milliseconds. */
-    ready(timeout?: number): Promise<void>;
-    /** connect to a server. */
-    connect(): void;
-    /** disconnect from a server. */
-    disconnect(): void;
-    setToken(token: string): void;
-    /** send asynchronous data to a server (without any response from a server
-     * expected, see rpc method if you need response). */
-    send(data: any): Promise<void>;
-    /** rpc to a server - i.e. a call which waits for a response with data. */
-    rpc(method: string, data: any): Promise<RpcResult>;
-    /** publish data to a channel. */
-    publish(channel: string, data: any): Promise<PublishResult>;
-    /** history for a channel. By default it does not return publications (only current
-     *  StreamPosition data) – provide an explicit limit > 0 to load publications.*/
-    history(channel: string, options?: HistoryOptions): Promise<HistoryResult>;
-    /** presence for a channel. */
-    presence(channel: string): Promise<PresenceResult>;
-    /** presence stats for a channel. */
-    presenceStats(channel: string): Promise<PresenceStatsResult>;
-    /** start command batching (collect into temporary buffer without sending to a server)
-     * until stopBatching called.*/
-    startBatching(): void;
-    /** stop batching commands and flush collected commands to the
-     * network (all in one request/frame).*/
-    stopBatching(): void;
-    private _debug;
-    private _configure;
-    private _setState;
-    private _isDisconnected;
-    private _isConnecting;
-    private _isConnected;
-    private _nextCommandId;
-    private _setNetworkEvents;
-    private _getReconnectDelay;
-    private _clearOutgoingRequests;
-    private _clearConnectedState;
-    private _handleWriteError;
-    private _transportSendCommands;
-    private _initializeTransport;
-    private _sendConnect;
-    private _startReconnecting;
-    private _connectError;
-    private _scheduleReconnect;
-    private _constructConnectCommand;
-    private _getHistoryRequest;
-    private _methodCall;
-    private _callPromise;
-    private _dataReceived;
-    private _dispatchSynchronized;
-    private _dispatchReply;
-    private _call;
-    private _startConnecting;
-    private _disconnect;
-    private _failUnauthorized;
-    private _getToken;
-    private _refresh;
-    private _refreshError;
-    private _getRefreshRetryDelay;
-    private _refreshResponse;
-    private _removeSubscription;
-    protected _unsubscribe(sub: Subscription): void;
-    private _getSub;
-    private _isServerSub;
-    private _sendSubscribeCommands;
-    private _connectResponse;
-    private _processServerSubs;
-    private _clearRefreshTimeout;
-    private _clearReconnectTimeout;
-    private _clearServerPingTimeout;
-    private _waitServerPing;
-    private _getSubscribeContext;
-    private _handleReply;
-    private _handleJoin;
-    private _handleLeave;
-    private _handleUnsubscribe;
-    private _handleSubscribe;
-    private _handleDisconnect;
-    private _getPublicationContext;
-    private _getJoinLeaveContext;
-    private _handlePublication;
-    private _handleMessage;
-    private _handleServerPing;
-    private _handlePush;
-    private _flush;
-    private _createErrorObject;
-    private _registerCall;
-    private _addCommand;
-    private _nextPromiseId;
-    private _nextTransportId;
-    private _resolvePromises;
-    private _rejectPromises;
-}
-export {};
+import { Subscription } from './subscription';
+import { State, Options, ClientEvents, TypedEventEmitter, RpcResult, SubscriptionOptions, HistoryOptions, HistoryResult, PublishResult, PresenceResult, PresenceStatsResult, TransportEndpoint } from './types';
+export declare class UnauthorizedError extends Error {
+    constructor(message: any);
+}
+declare const Centrifuge_base: new () => TypedEventEmitter<ClientEvents>;
+/** Centrifuge is a Centrifuge/Centrifugo bidirectional client. */
+export declare class Centrifuge extends Centrifuge_base {
+    state: State;
+    private _endpoint;
+    private _emulation;
+    private _transports;
+    private _currentTransportIndex;
+    private _triedAllTransports;
+    private _transportWasOpen;
+    private _transport?;
+    private _transportId;
+    private _deviceWentOffline;
+    private _transportClosed;
+    private _reconnecting;
+    private _reconnectTimeout?;
+    private _reconnectAttempts;
+    private _client;
+    private _session;
+    private _node;
+    private _subs;
+    private _serverSubs;
+    private _commandId;
+    private _commands;
+    private _batching;
+    private _refreshRequired;
+    private _refreshTimeout?;
+    private _callbacks;
+    private _token;
+    private _data;
+    private _dispatchPromise;
+    private _serverPing;
+    private _serverPingTimeout?;
+    private _sendPong;
+    private _promises;
+    private _promiseId;
+    private _networkEventsSet;
+    private _debugEnabled;
+    private _config;
+    protected _codec: any;
+    /** Constructs Centrifuge client. Call connect() method to start connecting. */
+    constructor(endpoint: string | Array<TransportEndpoint>, options?: Partial<Options>);
+    /** newSubscription allocates new Subscription to a channel. Since server only allows
+     * one subscription per channel per client this method throws if client already has
+     * channel subscription in internal registry.
+     * */
+    newSubscription(channel: string, options?: Partial<SubscriptionOptions>): Subscription;
+    /** getSubscription returns Subscription if it's registered in the internal
+     * registry or null. */
+    getSubscription(channel: string): Subscription | null;
+    /** removeSubscription allows removing Subcription from the internal registry. Subscrption
+     * must be in unsubscribed state. */
+    removeSubscription(sub: Subscription | null): void;
+    /** Get a map with all current client-side subscriptions. */
+    subscriptions(): Record<string, Subscription>;
+    /** ready returns a Promise which resolves upon client goes to Connected
+     * state and rejects in case of client goes to Disconnected or Failed state.
+     * Users can provide optional timeout in milliseconds. */
+    ready(timeout?: number): Promise<void>;
+    /** connect to a server. */
+    connect(): void;
+    /** disconnect from a server. */
+    disconnect(): void;
+    /** setToken allows setting connection token. Or resetting used token to be empty.  */
+    setToken(token: string): void;
+    /** send asynchronous data to a server (without any response from a server
+     * expected, see rpc method if you need response). */
+    send(data: any): Promise<void>;
+    /** rpc to a server - i.e. a call which waits for a response with data. */
+    rpc(method: string, data: any): Promise<RpcResult>;
+    /** publish data to a channel. */
+    publish(channel: string, data: any): Promise<PublishResult>;
+    /** history for a channel. By default it does not return publications (only current
+     *  StreamPosition data) – provide an explicit limit > 0 to load publications.*/
+    history(channel: string, options?: HistoryOptions): Promise<HistoryResult>;
+    /** presence for a channel. */
+    presence(channel: string): Promise<PresenceResult>;
+    /** presence stats for a channel. */
+    presenceStats(channel: string): Promise<PresenceStatsResult>;
+    /** start command batching (collect into temporary buffer without sending to a server)
+     * until stopBatching called.*/
+    startBatching(): void;
+    /** stop batching commands and flush collected commands to the
+     * network (all in one request/frame).*/
+    stopBatching(): void;
+    private _debug;
+    private _configure;
+    private _setState;
+    private _isDisconnected;
+    private _isConnecting;
+    private _isConnected;
+    private _nextCommandId;
+    private _setNetworkEvents;
+    private _getReconnectDelay;
+    private _clearOutgoingRequests;
+    private _clearConnectedState;
+    private _handleWriteError;
+    private _transportSendCommands;
+    private _initializeTransport;
+    private _sendConnect;
+    private _startReconnecting;
+    private _connectError;
+    private _scheduleReconnect;
+    private _constructConnectCommand;
+    private _getHistoryRequest;
+    private _methodCall;
+    private _callPromise;
+    private _dataReceived;
+    private _dispatchSynchronized;
+    private _dispatchReply;
+    private _call;
+    private _startConnecting;
+    private _disconnect;
+    private _failUnauthorized;
+    private _getToken;
+    private _refresh;
+    private _refreshError;
+    private _getRefreshRetryDelay;
+    private _refreshResponse;
+    private _removeSubscription;
+    protected _unsubscribe(sub: Subscription): void;
+    private _getSub;
+    private _isServerSub;
+    private _sendSubscribeCommands;
+    private _connectResponse;
+    private _processServerSubs;
+    private _clearRefreshTimeout;
+    private _clearReconnectTimeout;
+    private _clearServerPingTimeout;
+    private _waitServerPing;
+    private _getSubscribeContext;
+    private _handleReply;
+    private _handleJoin;
+    private _handleLeave;
+    private _handleUnsubscribe;
+    private _handleSubscribe;
+    private _handleDisconnect;
+    private _getPublicationContext;
+    private _getJoinLeaveContext;
+    private _handlePublication;
+    private _handleMessage;
+    private _handleServerPing;
+    private _handlePush;
+    private _flush;
+    private _createErrorObject;
+    private _registerCall;
+    private _addCommand;
+    private _nextPromiseId;
+    private _nextTransportId;
+    private _resolvePromises;
+    private _rejectPromises;
+}
+export {};

package/build/cjs/centrifuge.d.ts

@@ -0,0 +1,158 @@
+import { Subscription } from './subscription';
+import { State, Options, ClientEvents, TypedEventEmitter, RpcResult, SubscriptionOptions, HistoryOptions, HistoryResult, PublishResult, PresenceResult, PresenceStatsResult, TransportEndpoint } from './types';
+export declare class UnauthorizedError extends Error {
+    constructor(message: any);
+}
+declare const Centrifuge_base: new () => TypedEventEmitter<ClientEvents>;
+/** Centrifuge is a Centrifuge/Centrifugo bidirectional client. */
+export declare class Centrifuge extends Centrifuge_base {
+    state: State;
+    private _endpoint;
+    private _emulation;
+    private _transports;
+    private _currentTransportIndex;
+    private _triedAllTransports;
+    private _transportWasOpen;
+    private _transport?;
+    private _transportId;
+    private _deviceWentOffline;
+    private _transportClosed;
+    private _reconnecting;
+    private _reconnectTimeout?;
+    private _reconnectAttempts;
+    private _client;
+    private _session;
+    private _node;
+    private _subs;
+    private _serverSubs;
+    private _commandId;
+    private _commands;
+    private _batching;
+    private _refreshRequired;
+    private _refreshTimeout?;
+    private _callbacks;
+    private _token;
+    private _data;
+    private _dispatchPromise;
+    private _serverPing;
+    private _serverPingTimeout?;
+    private _sendPong;
+    private _promises;
+    private _promiseId;
+    private _networkEventsSet;
+    private _debugEnabled;
+    private _config;
+    protected _codec: any;
+    /** Constructs Centrifuge client. Call connect() method to start connecting. */
+    constructor(endpoint: string | Array<TransportEndpoint>, options?: Partial<Options>);
+    /** newSubscription allocates new Subscription to a channel. Since server only allows
+     * one subscription per channel per client this method throws if client already has
+     * channel subscription in internal registry.
+     * */
+    newSubscription(channel: string, options?: Partial<SubscriptionOptions>): Subscription;
+    /** getSubscription returns Subscription if it's registered in the internal
+     * registry or null. */
+    getSubscription(channel: string): Subscription | null;
+    /** removeSubscription allows removing Subcription from the internal registry. Subscrption
+     * must be in unsubscribed state. */
+    removeSubscription(sub: Subscription | null): void;
+    /** Get a map with all current client-side subscriptions. */
+    subscriptions(): Record<string, Subscription>;
+    /** ready returns a Promise which resolves upon client goes to Connected
+     * state and rejects in case of client goes to Disconnected or Failed state.
+     * Users can provide optional timeout in milliseconds. */
+    ready(timeout?: number): Promise<void>;
+    /** connect to a server. */
+    connect(): void;
+    /** disconnect from a server. */
+    disconnect(): void;
+    /** setToken allows setting connection token. Or resetting used token to be empty.  */
+    setToken(token: string): void;
+    /** send asynchronous data to a server (without any response from a server
+     * expected, see rpc method if you need response). */
+    send(data: any): Promise<void>;
+    /** rpc to a server - i.e. a call which waits for a response with data. */
+    rpc(method: string, data: any): Promise<RpcResult>;
+    /** publish data to a channel. */
+    publish(channel: string, data: any): Promise<PublishResult>;
+    /** history for a channel. By default it does not return publications (only current
+     *  StreamPosition data) – provide an explicit limit > 0 to load publications.*/
+    history(channel: string, options?: HistoryOptions): Promise<HistoryResult>;
+    /** presence for a channel. */
+    presence(channel: string): Promise<PresenceResult>;
+    /** presence stats for a channel. */
+    presenceStats(channel: string): Promise<PresenceStatsResult>;
+    /** start command batching (collect into temporary buffer without sending to a server)
+     * until stopBatching called.*/
+    startBatching(): void;
+    /** stop batching commands and flush collected commands to the
+     * network (all in one request/frame).*/
+    stopBatching(): void;
+    private _debug;
+    private _configure;
+    private _setState;
+    private _isDisconnected;
+    private _isConnecting;
+    private _isConnected;
+    private _nextCommandId;
+    private _setNetworkEvents;
+    private _getReconnectDelay;
+    private _clearOutgoingRequests;
+    private _clearConnectedState;
+    private _handleWriteError;
+    private _transportSendCommands;
+    private _initializeTransport;
+    private _sendConnect;
+    private _startReconnecting;
+    private _connectError;
+    private _scheduleReconnect;
+    private _constructConnectCommand;
+    private _getHistoryRequest;
+    private _methodCall;
+    private _callPromise;
+    private _dataReceived;
+    private _dispatchSynchronized;
+    private _dispatchReply;
+    private _call;
+    private _startConnecting;
+    private _disconnect;
+    private _failUnauthorized;
+    private _getToken;
+    private _refresh;
+    private _refreshError;
+    private _getRefreshRetryDelay;
+    private _refreshResponse;
+    private _removeSubscription;
+    protected _unsubscribe(sub: Subscription): void;
+    private _getSub;
+    private _isServerSub;
+    private _sendSubscribeCommands;
+    private _connectResponse;
+    private _processServerSubs;
+    private _clearRefreshTimeout;
+    private _clearReconnectTimeout;
+    private _clearServerPingTimeout;
+    private _waitServerPing;
+    private _getSubscribeContext;
+    private _handleReply;
+    private _handleJoin;
+    private _handleLeave;
+    private _handleUnsubscribe;
+    private _handleSubscribe;
+    private _handleDisconnect;
+    private _getPublicationContext;
+    private _getJoinLeaveContext;
+    private _handlePublication;
+    private _handleMessage;
+    private _handleServerPing;
+    private _handlePush;
+    private _flush;
+    private _createErrorObject;
+    private _registerCall;
+    private _addCommand;
+    private _nextPromiseId;
+    private _nextTransportId;
+    private _resolvePromises;
+    private _rejectPromises;
+}
+export {};

package/build/cjs/codes.d.ts

@@ -0,0 +1,36 @@
+export declare enum errorCodes {
+    timeout = 1,
+    transportClosed = 2,
+    clientDisconnected = 3,
+    clientClosed = 4,
+    clientConnectToken = 5,
+    clientRefreshToken = 6,
+    subscriptionUnsubscribed = 7,
+    subscriptionSubscribeToken = 8,
+    subscriptionRefreshToken = 9,
+    transportWriteError = 10,
+    connectionClosed = 11,
+    badConfiguration = 12
+}
+export declare enum connectingCodes {
+    connectCalled = 0,
+    transportClosed = 1,
+    noPing = 2,
+    subscribeTimeout = 3,
+    unsubscribeError = 4
+}
+export declare enum disconnectedCodes {
+    disconnectCalled = 0,
+    unauthorized = 1,
+    badProtocol = 2,
+    messageSizeLimit = 3
+}
+export declare enum subscribingCodes {
+    subscribeCalled = 0,
+    transportClosed = 1
+}
+export declare enum unsubscribedCodes {
+    unsubscribeCalled = 0,
+    unauthorized = 1,
+    clientClosed = 2
+}

package/build/cjs/protobuf.d.ts

@@ -0,0 +1,8 @@
+import { Centrifuge, UnauthorizedError } from './centrifuge';
+import { Subscription } from './subscription';
+export * from "./types";
+export * from "./codes";
+declare class CentrifugeProtobuf extends Centrifuge {
+    protected _formatOverride(): void;
+}
+export { CentrifugeProtobuf as Centrifuge, UnauthorizedError, Subscription };