@supabase/realtime-js 2.11.4-next.1 → 2.11.5

package/src/RealtimeClient.ts

@@ -1,3 +1,5 @@
+import type { WebSocket as WSWebSocket } from 'ws'
+
 import {
   CHANNEL_EVENTS,
   CONNECTION_STATE,
@@ -7,7 +9,9 @@ import {
   TRANSPORTS,
   VSN,
   WS_CLOSE_NORMAL,
+  LOG_LEVEL,
 } from './lib/constants'
+
 import Serializer from './lib/serializer'
 import Timer from './lib/timer'
 
@@ -23,23 +27,7 @@ export type Channel = {
   updated_at: string
   id: number
 }
-
-export type RealtimeClientOptions = {
-  transport?: WebSocketLikeConstructor
-  timeout?: number
-  heartbeatIntervalMs?: number
-  logger?: Function
-  encode?: Function
-  decode?: Function
-  reconnectAfterMs?: Function
-  headers?: { [key: string]: string }
-  params?: { [key: string]: any }
-  log_level?: 'info' | 'debug' | 'warn' | 'error'
-  fetch?: Fetch
-  worker?: boolean
-  workerUrl?: string
-  accessToken?: () => Promise<string | null>
-}
+export type LogLevel = LOG_LEVEL
 
 export type RealtimeMessage = {
   topic: string
@@ -60,13 +48,8 @@ export interface WebSocketLikeConstructor {
     options?: { headers: Object | undefined }
   ): WebSocketLike
 }
-const NATIVE_WEBSOCKET_AVAILABLE = typeof WebSocket !== 'undefined'
-
-const WSWebSocket = NATIVE_WEBSOCKET_AVAILABLE
-  ? WebSocket
-  : require('ws').WebSocket
 
-export type WebSocketLike = WebSocket | typeof WSWebSocket | WSWebSocketDummy
+export type WebSocketLike = WebSocket | WSWebSocket | WSWebSocketDummy
 
 export interface WebSocketLikeError {
   error: any
@@ -74,6 +57,26 @@ export interface WebSocketLikeError {
   type: string
 }
 
+export type RealtimeClientOptions = {
+  transport?: WebSocketLikeConstructor
+  timeout?: number
+  heartbeatIntervalMs?: number
+  logger?: Function
+  encode?: Function
+  decode?: Function
+  reconnectAfterMs?: Function
+  headers?: { [key: string]: string }
+  params?: { [key: string]: any }
+  //Deprecated: Use it in favour of correct casing `logLevel`
+  log_level?: LogLevel
+  logLevel?: LogLevel
+  fetch?: Fetch
+  worker?: boolean
+  workerUrl?: string
+  accessToken?: () => Promise<string | null>
+}
+
+const NATIVE_WEBSOCKET_AVAILABLE = typeof WebSocket !== 'undefined'
 const WORKER_SCRIPT = `
   addEventListener("message", (e) => {
     if (e.data.event === "start") {
@@ -90,12 +93,13 @@ export default class RealtimeClient {
   params?: { [key: string]: string } = {}
   timeout: number = DEFAULT_TIMEOUT
   transport: WebSocketLikeConstructor | null
-  heartbeatIntervalMs: number = 30000
+  heartbeatIntervalMs: number = 25000
   heartbeatTimer: ReturnType<typeof setInterval> | undefined = undefined
   pendingHeartbeatRef: string | null = null
   ref: number = 0
   reconnectTimer: Timer
   logger: Function = noop
+  logLevel?: LogLevel
   encode: Function
   decode: Function
   reconnectAfterMs: Function
@@ -130,6 +134,7 @@ export default class RealtimeClient {
    * @param options.headers The optional headers to pass when connecting.
    * @param options.heartbeatIntervalMs The millisec interval to send a heartbeat message.
    * @param options.logger The optional function for specialized logging, ie: logger: (kind, msg, data) => { console.log(`${kind}: ${msg}`, data) }
+   * @param options.logLevel Sets the log level for Realtime
    * @param options.encode The function to encode outgoing messages. Defaults to JSON: (payload, callback) => callback(JSON.stringify(payload))
    * @param options.decode The function to decode incoming messages. Defaults to Serializer's decode.
    * @param options.reconnectAfterMs he optional function that returns the millsec reconnect interval. Defaults to stepped backoff off.
@@ -148,6 +153,11 @@ export default class RealtimeClient {
     if (options?.headers) this.headers = { ...this.headers, ...options.headers }
     if (options?.timeout) this.timeout = options.timeout
     if (options?.logger) this.logger = options.logger
+    if (options?.logLevel || options?.log_level) {
+      this.logLevel = options.logLevel || options.log_level
+      this.params = { ...this.params, log_level: this.logLevel as string }
+    }
+
     if (options?.heartbeatIntervalMs)
       this.heartbeatIntervalMs = options.heartbeatIntervalMs
 
@@ -206,20 +216,20 @@ export default class RealtimeClient {
       this.conn = new WebSocket(this.endpointURL())
       this.setupConnection()
       return
-    } else {
-      this.conn = new WSWebSocketDummy(this.endpointURL(), undefined, {
-        close: () => {
-          this.conn = null
-        },
-      })
+    }
+
+    this.conn = new WSWebSocketDummy(this.endpointURL(), undefined, {
+      close: () => {
+        this.conn = null
+      },
+    })
 
-      import('ws').then(({ default: WS }) => {
-        this.conn = new WS(this.endpointURL(), undefined, {
-          headers: this.headers,
-        })
-        this.setupConnection()
+    import('ws').then(({ default: WS }) => {
+      this.conn = new WS(this.endpointURL(), undefined, {
+        headers: this.headers,
       })
-    }
+      this.setupConnection()
+    })
   }
 
   /**
@@ -362,28 +372,14 @@ export default class RealtimeClient {
       (this.accessToken && (await this.accessToken())) ||
       this.accessTokenValue
 
-    if (tokenToSend) {
-      let parsed = null
-      try {
-        parsed = JSON.parse(atob(tokenToSend.split('.')[1]))
-      } catch (_error) {}
-      if (parsed && parsed.exp) {
-        let now = Math.floor(Date.now() / 1000)
-        let valid = now - parsed.exp < 0
-        if (!valid) {
-          this.log(
-            'auth',
-            `InvalidJWTToken: Invalid value for JWT claim "exp" with value ${parsed.exp}`
-          )
-          return Promise.reject(
-            `InvalidJWTToken: Invalid value for JWT claim "exp" with value ${parsed.exp}`
-          )
-        }
-      }
-
+    if (this.accessTokenValue != tokenToSend) {
       this.accessTokenValue = tokenToSend
       this.channels.forEach((channel) => {
-        tokenToSend && channel.updateJoinPayload({ access_token: tokenToSend })
+        tokenToSend &&
+          channel.updateJoinPayload({
+            access_token: tokenToSend,
+            version: this.headers && this.headers['X-Client-Info'],
+          })
 
         if (channel.joinedOnce && channel._isJoined()) {
           channel._push(CHANNEL_EVENTS.access_token, {
@@ -416,7 +412,7 @@ export default class RealtimeClient {
       payload: {},
       ref: this.pendingHeartbeatRef,
     })
-    this.setAuth()
+    await this.setAuth()
   }
 
   /**

package/src/lib/constants.ts

@@ -4,6 +4,8 @@ export const DEFAULT_HEADERS = { 'X-Client-Info': `realtime-js/${version}` }
 
 export const VSN: string = '1.0.0'
 
+export const VERSION = version
+
 export const DEFAULT_TIMEOUT = 10000
 
 export const WS_CLOSE_NORMAL = 1000
@@ -42,3 +44,9 @@ export enum CONNECTION_STATE {
   Closing = 'closing',
   Closed = 'closed',
 }
+
+export enum LOG_LEVEL {
+  Info = 'info',
+  Warn = 'warn',
+  Error = 'error',
+}

package/src/lib/version.ts

@@ -1 +1 @@
-export const version = '2.11.4-next.1'
+export const version = '2.11.5'