@supabase/realtime-js 2.99.3-canary.0 → 2.99.3

package/src/RealtimeChannel.ts

@@ -1,6 +1,7 @@
-import { CHANNEL_EVENTS, CHANNEL_STATES } from './lib/constants'
-import type { ChannelState } from './lib/constants'
+import { CHANNEL_EVENTS, CHANNEL_STATES, MAX_PUSH_BUFFER_SIZE } from './lib/constants'
+import Push from './lib/push'
 import type RealtimeClient from './RealtimeClient'
+import Timer from './lib/timer'
 import RealtimePresence, { REALTIME_PRESENCE_LISTEN_EVENTS } from './RealtimePresence'
 import type {
   RealtimePresenceJoinPayload,
@@ -9,8 +10,6 @@ import type {
 } from './RealtimePresence'
 import * as Transformers from './lib/transformers'
 import { httpEndpointURL } from './lib/transformers'
-import ChannelAdapter from './phoenix/channelAdapter'
-import { ChannelBindingCallback, ChannelOnErrorCallback } from './phoenix/types'
 
 type ReplayOption = {
   since: number
@@ -148,7 +147,7 @@ export enum REALTIME_SUBSCRIBE_STATES {
 
 export const REALTIME_CHANNEL_STATES = CHANNEL_STATES
 
-type PostgresChangesFilters = {
+interface PostgresChangesFilters {
   postgres_changes: {
     id: string
     event: string
@@ -157,52 +156,30 @@ type PostgresChangesFilters = {
     filter?: string
   }[]
 }
-
-type Binding = {
-  type: string
-  filter: { [key: string]: any }
-  callback: ChannelBindingCallback
-  ref: number
-  id?: string
-}
-
 /** A channel is the basic building block of Realtime
  * and narrows the scope of data flow to subscribed clients.
  * You can think of a channel as a chatroom where participants are able to see who's online
  * and send and receive messages.
  */
 export default class RealtimeChannel {
-  bindings: Record<string, Binding[]> = {}
-  subTopic: string
+  bindings: {
+    [key: string]: {
+      type: string
+      filter: { [key: string]: any }
+      callback: Function
+      id?: string
+    }[]
+  } = {}
+  timeout: number
+  state: CHANNEL_STATES = CHANNEL_STATES.closed
+  joinedOnce = false
+  joinPush: Push
+  rejoinTimer: Timer
+  pushBuffer: Push[] = []
+  presence: RealtimePresence
   broadcastEndpointURL: string
+  subTopic: string
   private: boolean
-  presence: RealtimePresence
-  /** @internal */
-  channelAdapter: ChannelAdapter
-
-  get state() {
-    return this.channelAdapter.state
-  }
-
-  set state(state: ChannelState) {
-    this.channelAdapter.state = state
-  }
-
-  get joinedOnce() {
-    return this.channelAdapter.joinedOnce
-  }
-
-  get timeout() {
-    return this.socket.timeout
-  }
-
-  get joinPush() {
-    return this.channelAdapter.joinPush
-  }
-
-  get rejoinTimer() {
-    return this.channelAdapter.rejoinTimer
-  }
 
   /**
    * Creates a channel that can broadcast messages, sync presence, and listen to Postgres changes.
@@ -235,17 +212,53 @@ export default class RealtimeChannel {
       },
       ...params.config,
     }
-
-    this.channelAdapter = new ChannelAdapter(this.socket.socketAdapter, topic, this.params)
-    this.presence = new RealtimePresence(this)
-
+    this.timeout = this.socket.timeout
+    this.joinPush = new Push(this, CHANNEL_EVENTS.join, this.params, this.timeout)
+    this.rejoinTimer = new Timer(() => this._rejoinUntilConnected(), this.socket.reconnectAfterMs)
+    this.joinPush.receive('ok', () => {
+      this.state = CHANNEL_STATES.joined
+      this.rejoinTimer.reset()
+      this.pushBuffer.forEach((pushEvent: Push) => pushEvent.send())
+      this.pushBuffer = []
+    })
     this._onClose(() => {
+      this.rejoinTimer.reset()
+      this.socket.log('channel', `close ${this.topic} ${this._joinRef()}`)
+      this.state = CHANNEL_STATES.closed
       this.socket._remove(this)
     })
+    this._onError((reason: string) => {
+      if (this._isLeaving() || this._isClosed()) {
+        return
+      }
+      this.socket.log('channel', `error ${this.topic}`, reason)
+      this.state = CHANNEL_STATES.errored
+      this.rejoinTimer.scheduleTimeout()
+    })
+    this.joinPush.receive('timeout', () => {
+      if (!this._isJoining()) {
+        return
+      }
+      this.socket.log('channel', `timeout ${this.topic}`, this.joinPush.timeout)
+      this.state = CHANNEL_STATES.errored
+      this.rejoinTimer.scheduleTimeout()
+    })
 
-    this._updateFilterTransform()
+    this.joinPush.receive('error', (reason: any) => {
+      if (this._isLeaving() || this._isClosed()) {
+        return
+      }
+      this.socket.log('channel', `error ${this.topic}`, reason)
+      this.state = CHANNEL_STATES.errored
+      this.rejoinTimer.scheduleTimeout()
+    })
+    this._on(CHANNEL_EVENTS.reply, {}, (payload: any, ref: string) => {
+      this._trigger(this._replyEventName(ref), payload)
+    })
+
+    this.presence = new RealtimePresence(this)
 
-    this.broadcastEndpointURL = httpEndpointURL(this.socket.socketAdapter.endPointURL())
+    this.broadcastEndpointURL = httpEndpointURL(this.socket.endPoint)
     this.private = this.params.config.private || false
 
     if (!this.private && this.params.config?.broadcast?.replay) {
@@ -261,7 +274,7 @@ export default class RealtimeChannel {
     if (!this.socket.isConnected()) {
       this.socket.connect()
     }
-    if (this.channelAdapter.isClosed()) {
+    if (this.state == CHANNEL_STATES.closed) {
       const {
         config: { broadcast, presence, private: isPrivate },
       } = this.params
@@ -284,18 +297,16 @@ export default class RealtimeChannel {
         accessTokenPayload.access_token = this.socket.accessTokenValue
       }
 
-      this._onError((reason: unknown) => {
-        callback?.(REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR, reason as Error)
-      })
+      this._onError((e: Error) => callback?.(REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR, e))
 
       this._onClose(() => callback?.(REALTIME_SUBSCRIBE_STATES.CLOSED))
 
       this.updateJoinPayload({ ...{ config }, ...accessTokenPayload })
 
-      this._updateFilterMessage()
+      this.joinedOnce = true
+      this._rejoin(timeout)
 
-      this.channelAdapter
-        .subscribe(timeout)
+      this.joinPush
         .receive('ok', async ({ postgres_changes }: PostgresChangesFilters) => {
           // Only refresh auth if using callback-based tokens
           if (!this.socket._isManualToken()) {
@@ -304,9 +315,46 @@ export default class RealtimeChannel {
           if (postgres_changes === undefined) {
             callback?.(REALTIME_SUBSCRIBE_STATES.SUBSCRIBED)
             return
+          } else {
+            const clientPostgresBindings = this.bindings.postgres_changes
+            const bindingsLen = clientPostgresBindings?.length ?? 0
+            const newPostgresBindings = []
+
+            for (let i = 0; i < bindingsLen; i++) {
+              const clientPostgresBinding = clientPostgresBindings[i]
+              const {
+                filter: { event, schema, table, filter },
+              } = clientPostgresBinding
+              const serverPostgresFilter = postgres_changes && postgres_changes[i]
+
+              if (
+                serverPostgresFilter &&
+                serverPostgresFilter.event === event &&
+                RealtimeChannel.isFilterValueEqual(serverPostgresFilter.schema, schema) &&
+                RealtimeChannel.isFilterValueEqual(serverPostgresFilter.table, table) &&
+                RealtimeChannel.isFilterValueEqual(serverPostgresFilter.filter, filter)
+              ) {
+                newPostgresBindings.push({
+                  ...clientPostgresBinding,
+                  id: serverPostgresFilter.id,
+                })
+              } else {
+                this.unsubscribe()
+                this.state = CHANNEL_STATES.errored
+
+                callback?.(
+                  REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR,
+                  new Error('mismatch between server and client bindings for postgres changes')
+                )
+                return
+              }
+            }
+
+            this.bindings.postgres_changes = newPostgresBindings
+
+            callback && callback(REALTIME_SUBSCRIBE_STATES.SUBSCRIBED)
+            return
           }
-
-          this._updatePostgresBindings(postgres_changes, callback)
         })
         .receive('error', (error: { [key: string]: any }) => {
           this.state = CHANNEL_STATES.errored
@@ -314,59 +362,16 @@ export default class RealtimeChannel {
             REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR,
             new Error(JSON.stringify(Object.values(error).join(', ') || 'error'))
           )
+          return
         })
         .receive('timeout', () => {
           callback?.(REALTIME_SUBSCRIBE_STATES.TIMED_OUT)
+          return
         })
     }
     return this
   }
 
-  private _updatePostgresBindings(
-    postgres_changes: PostgresChangesFilters['postgres_changes'],
-    callback?: (status: REALTIME_SUBSCRIBE_STATES, err?: Error) => void
-  ) {
-    const clientPostgresBindings = this.bindings.postgres_changes
-    const bindingsLen = clientPostgresBindings?.length ?? 0
-    const newPostgresBindings = []
-
-    for (let i = 0; i < bindingsLen; i++) {
-      const clientPostgresBinding = clientPostgresBindings[i]
-      const {
-        filter: { event, schema, table, filter },
-      } = clientPostgresBinding
-      const serverPostgresFilter = postgres_changes && postgres_changes[i]
-
-      if (
-        serverPostgresFilter &&
-        serverPostgresFilter.event === event &&
-        RealtimeChannel.isFilterValueEqual(serverPostgresFilter.schema, schema) &&
-        RealtimeChannel.isFilterValueEqual(serverPostgresFilter.table, table) &&
-        RealtimeChannel.isFilterValueEqual(serverPostgresFilter.filter, filter)
-      ) {
-        newPostgresBindings.push({
-          ...clientPostgresBinding,
-          id: serverPostgresFilter.id,
-        })
-      } else {
-        this.unsubscribe()
-        this.state = CHANNEL_STATES.errored
-
-        callback?.(
-          REALTIME_SUBSCRIBE_STATES.CHANNEL_ERROR,
-          new Error('mismatch between server and client bindings for postgres changes')
-        )
-        return
-      }
-    }
-
-    this.bindings.postgres_changes = newPostgresBindings
-
-    if (this.state != CHANNEL_STATES.errored && callback) {
-      callback(REALTIME_SUBSCRIBE_STATES.SUBSCRIBED)
-    }
-  }
-
   /**
    * Returns the current presence state for this channel.
    *
@@ -426,11 +431,6 @@ export default class RealtimeChannel {
     filter: { event: `${REALTIME_PRESENCE_LISTEN_EVENTS.LEAVE}` },
     callback: (payload: RealtimePresenceLeavePayload<T>) => void
   ): RealtimeChannel
-  on<T extends { [key: string]: any }>(
-    type: `${REALTIME_LISTEN_TYPES.PRESENCE}`,
-    filter: { event: '*' },
-    callback: (payload?: RealtimePresenceJoinPayload<T> | RealtimePresenceLeavePayload<T>) => void
-  ): RealtimeChannel
   on<T extends { [key: string]: any }>(
     type: `${REALTIME_LISTEN_TYPES.POSTGRES_CHANGES}`,
     filter: RealtimePostgresChangesFilter<`${REALTIME_POSTGRES_CHANGES_LISTEN_EVENT.ALL}`>,
@@ -534,9 +534,12 @@ export default class RealtimeChannel {
     filter: { event: string; [key: string]: string },
     callback: (payload: any) => void
   ): RealtimeChannel {
-    if (this.channelAdapter.isJoined() && type === REALTIME_LISTEN_TYPES.PRESENCE) {
-      this.socket.log('channel', `cannot add presence callbacks for ${this.topic} after joining.`)
-      throw new Error('cannot add presence callbacks after joining a channel')
+    if (this.state === CHANNEL_STATES.joined && type === REALTIME_LISTEN_TYPES.PRESENCE) {
+      this.socket.log(
+        'channel',
+        `resubscribe to ${this.topic} due to change in presence callbacks on joined channel`
+      )
+      this.unsubscribe().then(async () => await this.subscribe())
     }
     return this._on(type, filter, callback)
   }
@@ -621,7 +624,7 @@ export default class RealtimeChannel {
     },
     opts: { [key: string]: any } = {}
   ): Promise<RealtimeChannelSendResponse> {
-    if (!this.channelAdapter.canPush() && args.type === 'broadcast') {
+    if (!this._canPush() && args.type === 'broadcast') {
       console.warn(
         'Realtime send() is automatically falling back to REST API. ' +
           'This behavior will be deprecated in the future. ' +
@@ -671,7 +674,7 @@ export default class RealtimeChannel {
       }
     } else {
       return new Promise((resolve) => {
-        const push = this.channelAdapter.push(args.type, args, opts.timeout || this.timeout)
+        const push = this._push(args.type, args, opts.timeout || this.timeout)
 
         if (args.type === 'broadcast' && !this.params?.config?.broadcast?.ack) {
           resolve('ok')
@@ -688,8 +691,8 @@ export default class RealtimeChannel {
    * Updates the payload that will be sent the next time the channel joins (reconnects).
    * Useful for rotating access tokens or updating config without re-creating the channel.
    */
-  updateJoinPayload(payload: Record<string, any>) {
-    this.channelAdapter.updateJoinPayload(payload)
+  updateJoinPayload(payload: { [key: string]: any }): void {
+    this.joinPush.updatePayload(payload)
   }
 
   /**
@@ -701,24 +704,56 @@ export default class RealtimeChannel {
    * To receive leave acknowledgements, use the a `receive` hook to bind to the server ack, ie:
    * channel.unsubscribe().receive("ok", () => alert("left!") )
    */
-  async unsubscribe(timeout = this.timeout) {
+  unsubscribe(timeout = this.timeout): Promise<'ok' | 'timed out' | 'error'> {
+    this.state = CHANNEL_STATES.leaving
+    const onClose = () => {
+      this.socket.log('channel', `leave ${this.topic}`)
+      this._trigger(CHANNEL_EVENTS.close, 'leave', this._joinRef())
+    }
+
+    this.joinPush.destroy()
+
+    let leavePush: Push | null = null
+
     return new Promise<RealtimeChannelSendResponse>((resolve) => {
-      this.channelAdapter
-        .unsubscribe(timeout)
-        .receive('ok', () => resolve('ok'))
-        .receive('timeout', () => resolve('timed out'))
-        .receive('error', () => resolve('error'))
+      leavePush = new Push(this, CHANNEL_EVENTS.leave, {}, timeout)
+      leavePush
+        .receive('ok', () => {
+          onClose()
+          resolve('ok')
+        })
+        .receive('timeout', () => {
+          onClose()
+          resolve('timed out')
+        })
+        .receive('error', () => {
+          resolve('error')
+        })
+
+      leavePush.send()
+      if (!this._canPush()) {
+        leavePush.trigger('ok', {})
+      }
+    }).finally(() => {
+      leavePush?.destroy()
     })
   }
-
   /**
+   * Teardown the channel.
+   *
    * Destroys and stops related timers.
    */
   teardown() {
-    this.channelAdapter.teardown()
+    this.pushBuffer.forEach((push: Push) => push.destroy())
+    this.pushBuffer = []
+    this.rejoinTimer.reset()
+    this.joinPush.destroy()
+    this.state = CHANNEL_STATES.closed
+    this.bindings = {}
   }
 
   /** @internal */
+
   async _fetchWithTimeout(url: string, options: { [key: string]: any }, timeout: number) {
     const controller = new AbortController()
     const id = setTimeout(() => controller.abort(), timeout)
@@ -734,112 +769,195 @@ export default class RealtimeChannel {
   }
 
   /** @internal */
-  _on(type: string, filter: { [key: string]: any }, callback: ChannelBindingCallback) {
-    const typeLower = type.toLocaleLowerCase()
-
-    const ref = this.channelAdapter.on(type, callback)
-
-    const binding: Binding = {
-      type: typeLower,
-      filter: filter,
-      callback: callback,
-      ref: ref,
+  _push(event: string, payload: { [key: string]: any }, timeout = this.timeout) {
+    if (!this.joinedOnce) {
+      throw `tried to push '${event}' to '${this.topic}' before joining. Use channel.subscribe() before pushing events`
     }
-
-    if (this.bindings[typeLower]) {
-      this.bindings[typeLower].push(binding)
+    let pushEvent = new Push(this, event, payload, timeout)
+    if (this._canPush()) {
+      pushEvent.send()
     } else {
-      this.bindings[typeLower] = [binding]
+      this._addToPushBuffer(pushEvent)
     }
 
-    this._updateFilterMessage()
+    return pushEvent
+  }
 
-    return this
+  /** @internal */
+  _addToPushBuffer(pushEvent: Push) {
+    pushEvent.startTimeout()
+    this.pushBuffer.push(pushEvent)
+
+    // Enforce buffer size limit
+    if (this.pushBuffer.length > MAX_PUSH_BUFFER_SIZE) {
+      const removedPush = this.pushBuffer.shift()
+      if (removedPush) {
+        removedPush.destroy()
+        this.socket.log(
+          'channel',
+          `discarded push due to buffer overflow: ${removedPush.event}`,
+          removedPush.payload
+        )
+      }
+    }
   }
 
   /**
-   * Registers a callback that will be executed when the channel closes.
+   * Overridable message hook
+   *
+   * Receives all events for specialized message handling before dispatching to the channel callbacks.
+   * Must return the payload, modified or unmodified.
    *
    * @internal
    */
-  private _onClose(callback: ChannelBindingCallback) {
-    this.channelAdapter.onClose(callback)
+  _onMessage(_event: string, payload: any, _ref?: string) {
+    return payload
   }
 
-  /**
-   * Registers a callback that will be executed when the channel encounteres an error.
-   *
-   * @internal
-   */
-  private _onError(callback: ChannelOnErrorCallback) {
-    this.channelAdapter.onError(callback)
+  /** @internal */
+  _isMember(topic: string): boolean {
+    return this.topic === topic
   }
 
   /** @internal */
-  private _updateFilterMessage() {
-    this.channelAdapter.updateFilterBindings((binding, payload: any, ref) => {
-      const typeLower = binding.event.toLocaleLowerCase()
+  _joinRef(): string {
+    return this.joinPush.ref
+  }
 
-      if (this._notThisChannelEvent(typeLower, ref)) {
-        return false
-      }
+  /** @internal */
+  _trigger(type: string, payload?: any, ref?: string) {
+    const typeLower = type.toLocaleLowerCase()
+    const { close, error, leave, join } = CHANNEL_EVENTS
+    const events: string[] = [close, error, leave, join]
+    if (ref && events.indexOf(typeLower) >= 0 && ref !== this._joinRef()) {
+      return
+    }
+    let handledPayload = this._onMessage(typeLower, payload, ref)
+    if (payload && !handledPayload) {
+      throw 'channel onMessage callbacks must return the payload, modified or unmodified'
+    }
 
-      const bind = this.bindings[typeLower]?.find((bind) => bind.ref === binding.ref)
+    if (['insert', 'update', 'delete'].includes(typeLower)) {
+      this.bindings.postgres_changes
+        ?.filter((bind) => {
+          return bind.filter?.event === '*' || bind.filter?.event?.toLocaleLowerCase() === typeLower
+        })
+        .map((bind) => bind.callback(handledPayload, ref))
+    } else {
+      this.bindings[typeLower]
+        ?.filter((bind) => {
+          if (['broadcast', 'presence', 'postgres_changes'].includes(typeLower)) {
+            if ('id' in bind) {
+              const bindId = bind.id
+              const bindEvent = bind.filter?.event
+              return (
+                bindId &&
+                payload.ids?.includes(bindId) &&
+                (bindEvent === '*' ||
+                  bindEvent?.toLocaleLowerCase() === payload.data?.type.toLocaleLowerCase())
+              )
+            } else {
+              const bindEvent = bind?.filter?.event?.toLocaleLowerCase()
+              return bindEvent === '*' || bindEvent === payload?.event?.toLocaleLowerCase()
+            }
+          } else {
+            return bind.type.toLocaleLowerCase() === typeLower
+          }
+        })
+        .map((bind) => {
+          if (typeof handledPayload === 'object' && 'ids' in handledPayload) {
+            const postgresChanges = handledPayload.data
+            const { schema, table, commit_timestamp, type, errors } = postgresChanges
+            const enrichedPayload = {
+              schema: schema,
+              table: table,
+              commit_timestamp: commit_timestamp,
+              eventType: type,
+              new: {},
+              old: {},
+              errors: errors,
+            }
+            handledPayload = {
+              ...enrichedPayload,
+              ...this._getPayloadRecords(postgresChanges),
+            }
+          }
+          bind.callback(handledPayload, ref)
+        })
+    }
+  }
 
-      if (!bind) {
-        return true
-      }
+  /** @internal */
+  _isClosed(): boolean {
+    return this.state === CHANNEL_STATES.closed
+  }
 
-      if (['broadcast', 'presence', 'postgres_changes'].includes(typeLower)) {
-        if ('id' in bind) {
-          const bindId = bind.id
-          const bindEvent = bind.filter?.event
-          return (
-            bindId &&
-            payload.ids?.includes(bindId) &&
-            (bindEvent === '*' ||
-              bindEvent?.toLocaleLowerCase() === payload.data?.type.toLocaleLowerCase())
-          )
-        } else {
-          const bindEvent = bind?.filter?.event?.toLocaleLowerCase()
-          return bindEvent === '*' || bindEvent === payload?.event?.toLocaleLowerCase()
-        }
-      } else {
-        return bind.type.toLocaleLowerCase() === typeLower
-      }
-    })
+  /** @internal */
+  _isJoined(): boolean {
+    return this.state === CHANNEL_STATES.joined
   }
 
   /** @internal */
-  private _notThisChannelEvent(event: string, ref?: string | null) {
-    const { close, error, leave, join } = CHANNEL_EVENTS
-    const events: string[] = [close, error, leave, join]
-    return ref && events.includes(event) && ref !== this.joinPush.ref
+  _isJoining(): boolean {
+    return this.state === CHANNEL_STATES.joining
   }
 
   /** @internal */
-  private _updateFilterTransform() {
-    this.channelAdapter.updatePayloadTransform((event, payload: any, ref) => {
-      if (typeof payload === 'object' && 'ids' in payload) {
-        const postgresChanges = payload.data
-        const { schema, table, commit_timestamp, type, errors } = postgresChanges
-        const enrichedPayload = {
-          schema: schema,
-          table: table,
-          commit_timestamp: commit_timestamp,
-          eventType: type,
-          new: {},
-          old: {},
-          errors: errors,
-        }
-        return {
-          ...enrichedPayload,
-          ...this._getPayloadRecords(postgresChanges),
-        }
+  _isLeaving(): boolean {
+    return this.state === CHANNEL_STATES.leaving
+  }
+
+  /** @internal */
+  _replyEventName(ref: string): string {
+    return `chan_reply_${ref}`
+  }
+
+  /** @internal */
+  _on(type: string, filter: { [key: string]: any }, callback: Function) {
+    const typeLower = type.toLocaleLowerCase()
+    const binding = {
+      type: typeLower,
+      filter: filter,
+      callback: callback,
+    }
+
+    if (this.bindings[typeLower]) {
+      this.bindings[typeLower].push(binding)
+    } else {
+      this.bindings[typeLower] = [binding]
+    }
+
+    return this
+  }
+
+  /** @internal */
+  _off(type: string, filter: { [key: string]: any }) {
+    const typeLower = type.toLocaleLowerCase()
+
+    if (this.bindings[typeLower]) {
+      this.bindings[typeLower] = this.bindings[typeLower].filter((bind) => {
+        return !(
+          bind.type?.toLocaleLowerCase() === typeLower &&
+          RealtimeChannel.isEqual(bind.filter, filter)
+        )
+      })
+    }
+    return this
+  }
+
+  /** @internal */
+  private static isEqual(obj1: { [key: string]: string }, obj2: { [key: string]: string }) {
+    if (Object.keys(obj1).length !== Object.keys(obj2).length) {
+      return false
+    }
+
+    for (const k in obj1) {
+      if (obj1[k] !== obj2[k]) {
+        return false
       }
+    }
 
-      return payload
-    })
+    return true
   }
 
   /**
@@ -856,6 +974,51 @@ export default class RealtimeChannel {
     return normalizedServer === normalizedClient
   }
 
+  /** @internal */
+  private _rejoinUntilConnected() {
+    this.rejoinTimer.scheduleTimeout()
+    if (this.socket.isConnected()) {
+      this._rejoin()
+    }
+  }
+
+  /**
+   * Registers a callback that will be executed when the channel closes.
+   *
+   * @internal
+   */
+  private _onClose(callback: Function) {
+    this._on(CHANNEL_EVENTS.close, {}, callback)
+  }
+
+  /**
+   * Registers a callback that will be executed when the channel encounteres an error.
+   *
+   * @internal
+   */
+  private _onError(callback: Function) {
+    this._on(CHANNEL_EVENTS.error, {}, (reason: string) => callback(reason))
+  }
+
+  /**
+   * Returns `true` if the socket is connected and the channel has been joined.
+   *
+   * @internal
+   */
+  private _canPush(): boolean {
+    return this.socket.isConnected() && this._isJoined()
+  }
+
+  /** @internal */
+  private _rejoin(timeout = this.timeout): void {
+    if (this._isLeaving()) {
+      return
+    }
+    this.socket._leaveOpenTopic(this.topic)
+    this.state = CHANNEL_STATES.joining
+    this.joinPush.resend(timeout)
+  }
+
   /** @internal */
   private _getPayloadRecords(payload: any) {
     const records = {