@depup/supabase__realtime-js 2.99.3-depup.0

package/src/lib/serializer.ts

@@ -0,0 +1,203 @@
+// This file draws heavily from https://github.com/phoenixframework/phoenix/commit/cf098e9cf7a44ee6479d31d911a97d3c7430c6fe
+// License: https://github.com/phoenixframework/phoenix/blob/master/LICENSE.md
+export type Msg<T> = {
+  join_ref?: string | null
+  ref?: string | null
+  topic: string
+  event: string
+  payload: T
+}
+
+export default class Serializer {
+  HEADER_LENGTH = 1
+  USER_BROADCAST_PUSH_META_LENGTH = 6
+  KINDS = { userBroadcastPush: 3, userBroadcast: 4 }
+  BINARY_ENCODING = 0
+  JSON_ENCODING = 1
+  BROADCAST_EVENT = 'broadcast'
+
+  allowedMetadataKeys: string[] = []
+
+  constructor(allowedMetadataKeys?: string[] | null) {
+    this.allowedMetadataKeys = allowedMetadataKeys ?? []
+  }
+
+  encode(msg: Msg<{ [key: string]: any }>, callback: (result: ArrayBuffer | string) => any) {
+    if (
+      msg.event === this.BROADCAST_EVENT &&
+      !(msg.payload instanceof ArrayBuffer) &&
+      typeof msg.payload.event === 'string'
+    ) {
+      return callback(
+        this._binaryEncodeUserBroadcastPush(msg as Msg<{ event: string } & { [key: string]: any }>)
+      )
+    }
+
+    let payload = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload]
+    return callback(JSON.stringify(payload))
+  }
+
+  private _binaryEncodeUserBroadcastPush(message: Msg<{ event: string } & { [key: string]: any }>) {
+    if (this._isArrayBuffer(message.payload?.payload)) {
+      return this._encodeBinaryUserBroadcastPush(message)
+    } else {
+      return this._encodeJsonUserBroadcastPush(message)
+    }
+  }
+
+  private _encodeBinaryUserBroadcastPush(message: Msg<{ event: string } & { [key: string]: any }>) {
+    const userPayload = message.payload?.payload ?? new ArrayBuffer(0)
+    return this._encodeUserBroadcastPush(message, this.BINARY_ENCODING, userPayload)
+  }
+
+  private _encodeJsonUserBroadcastPush(message: Msg<{ event: string } & { [key: string]: any }>) {
+    const userPayload = message.payload?.payload ?? {}
+    const encoder = new TextEncoder()
+    const encodedUserPayload = encoder.encode(JSON.stringify(userPayload)).buffer
+    return this._encodeUserBroadcastPush(message, this.JSON_ENCODING, encodedUserPayload)
+  }
+
+  private _encodeUserBroadcastPush(
+    message: Msg<{ event: string } & { [key: string]: any }>,
+    encodingType: number,
+    encodedPayload: ArrayBuffer
+  ) {
+    const topic = message.topic
+    const ref = message.ref ?? ''
+    const joinRef = message.join_ref ?? ''
+    const userEvent = message.payload.event
+
+    // Filter metadata based on allowed keys
+    const rest = this.allowedMetadataKeys
+      ? this._pick(message.payload, this.allowedMetadataKeys)
+      : {}
+
+    const metadata = Object.keys(rest).length === 0 ? '' : JSON.stringify(rest)
+
+    // Validate lengths don't exceed uint8 max value (255)
+    if (joinRef.length > 255) {
+      throw new Error(`joinRef length ${joinRef.length} exceeds maximum of 255`)
+    }
+    if (ref.length > 255) {
+      throw new Error(`ref length ${ref.length} exceeds maximum of 255`)
+    }
+    if (topic.length > 255) {
+      throw new Error(`topic length ${topic.length} exceeds maximum of 255`)
+    }
+    if (userEvent.length > 255) {
+      throw new Error(`userEvent length ${userEvent.length} exceeds maximum of 255`)
+    }
+    if (metadata.length > 255) {
+      throw new Error(`metadata length ${metadata.length} exceeds maximum of 255`)
+    }
+
+    const metaLength =
+      this.USER_BROADCAST_PUSH_META_LENGTH +
+      joinRef.length +
+      ref.length +
+      topic.length +
+      userEvent.length +
+      metadata.length
+
+    const header = new ArrayBuffer(this.HEADER_LENGTH + metaLength)
+    let view = new DataView(header)
+    let offset = 0
+
+    view.setUint8(offset++, this.KINDS.userBroadcastPush) // kind
+    view.setUint8(offset++, joinRef.length)
+    view.setUint8(offset++, ref.length)
+    view.setUint8(offset++, topic.length)
+    view.setUint8(offset++, userEvent.length)
+    view.setUint8(offset++, metadata.length)
+    view.setUint8(offset++, encodingType)
+    Array.from(joinRef, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+    Array.from(ref, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+    Array.from(topic, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+    Array.from(userEvent, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+    Array.from(metadata, (char) => view.setUint8(offset++, char.charCodeAt(0)))
+
+    var combined = new Uint8Array(header.byteLength + encodedPayload.byteLength)
+    combined.set(new Uint8Array(header), 0)
+    combined.set(new Uint8Array(encodedPayload), header.byteLength)
+
+    return combined.buffer
+  }
+
+  decode(rawPayload: ArrayBuffer | string, callback: Function) {
+    if (this._isArrayBuffer(rawPayload)) {
+      let result = this._binaryDecode(rawPayload as ArrayBuffer)
+      return callback(result)
+    }
+
+    if (typeof rawPayload === 'string') {
+      const jsonPayload = JSON.parse(rawPayload)
+      const [join_ref, ref, topic, event, payload] = jsonPayload
+      return callback({ join_ref, ref, topic, event, payload })
+    }
+
+    return callback({})
+  }
+
+  private _binaryDecode(buffer: ArrayBuffer) {
+    const view = new DataView(buffer)
+    const kind = view.getUint8(0)
+    const decoder = new TextDecoder()
+    switch (kind) {
+      case this.KINDS.userBroadcast:
+        return this._decodeUserBroadcast(buffer, view, decoder)
+    }
+  }
+
+  private _decodeUserBroadcast(
+    buffer: ArrayBuffer,
+    view: DataView,
+    decoder: TextDecoder
+  ): {
+    join_ref: null
+    ref: null
+    topic: string
+    event: string
+    payload: { [key: string]: any }
+  } {
+    const topicSize = view.getUint8(1)
+    const userEventSize = view.getUint8(2)
+    const metadataSize = view.getUint8(3)
+    const payloadEncoding = view.getUint8(4)
+
+    let offset = this.HEADER_LENGTH + 4
+    const topic = decoder.decode(buffer.slice(offset, offset + topicSize))
+    offset = offset + topicSize
+    const userEvent = decoder.decode(buffer.slice(offset, offset + userEventSize))
+    offset = offset + userEventSize
+    const metadata = decoder.decode(buffer.slice(offset, offset + metadataSize))
+    offset = offset + metadataSize
+
+    const payload = buffer.slice(offset, buffer.byteLength)
+    const parsedPayload =
+      payloadEncoding === this.JSON_ENCODING ? JSON.parse(decoder.decode(payload)) : payload
+
+    const data: { [key: string]: any } = {
+      type: this.BROADCAST_EVENT,
+      event: userEvent,
+      payload: parsedPayload,
+    }
+
+    // Metadata is optional and always JSON encoded
+    if (metadataSize > 0) {
+      data['meta'] = JSON.parse(metadata)
+    }
+
+    return { join_ref: null, ref: null, topic: topic, event: this.BROADCAST_EVENT, payload: data }
+  }
+
+  private _isArrayBuffer(buffer: any): boolean {
+    return buffer instanceof ArrayBuffer || buffer?.constructor?.name === 'ArrayBuffer'
+  }
+
+  private _pick(obj: Record<string, any> | null | undefined, keys: string[]): Record<string, any> {
+    if (!obj || typeof obj !== 'object') {
+      return {}
+    }
+    return Object.fromEntries(Object.entries(obj).filter(([key]) => keys.includes(key)))
+  }
+}

package/src/lib/timer.ts

@@ -0,0 +1,43 @@
+/**
+ * Creates a timer that accepts a `timerCalc` function to perform calculated timeout retries, such as exponential backoff.
+ *
+ * @example
+ *    let reconnectTimer = new Timer(() => this.connect(), function(tries){
+ *      return [1000, 5000, 10000][tries - 1] || 10000
+ *    })
+ *    reconnectTimer.scheduleTimeout() // fires after 1000
+ *    reconnectTimer.scheduleTimeout() // fires after 5000
+ *    reconnectTimer.reset()
+ *    reconnectTimer.scheduleTimeout() // fires after 1000
+ */
+export default class Timer {
+  timer: number | undefined = undefined
+  tries: number = 0
+
+  constructor(
+    public callback: Function,
+    public timerCalc: Function
+  ) {
+    this.callback = callback
+    this.timerCalc = timerCalc
+  }
+
+  reset() {
+    this.tries = 0
+    clearTimeout(this.timer)
+    this.timer = undefined
+  }
+
+  // Cancels any previous scheduleTimeout and schedules callback
+  scheduleTimeout() {
+    clearTimeout(this.timer)
+
+    this.timer = <any>setTimeout(
+      () => {
+        this.tries = this.tries + 1
+        this.callback()
+      },
+      this.timerCalc(this.tries + 1)
+    )
+  }
+}

package/src/lib/transformers.ts

@@ -0,0 +1,270 @@
+/**
+ * Helpers to convert the change Payload into native JS types.
+ */
+
+// Adapted from epgsql (src/epgsql_binary.erl), this module licensed under
+// 3-clause BSD found here: https://raw.githubusercontent.com/epgsql/epgsql/devel/LICENSE
+
+export enum PostgresTypes {
+  abstime = 'abstime',
+  bool = 'bool',
+  date = 'date',
+  daterange = 'daterange',
+  float4 = 'float4',
+  float8 = 'float8',
+  int2 = 'int2',
+  int4 = 'int4',
+  int4range = 'int4range',
+  int8 = 'int8',
+  int8range = 'int8range',
+  json = 'json',
+  jsonb = 'jsonb',
+  money = 'money',
+  numeric = 'numeric',
+  oid = 'oid',
+  reltime = 'reltime',
+  text = 'text',
+  time = 'time',
+  timestamp = 'timestamp',
+  timestamptz = 'timestamptz',
+  timetz = 'timetz',
+  tsrange = 'tsrange',
+  tstzrange = 'tstzrange',
+}
+
+type Columns = {
+  name: string // the column name. eg: "user_id"
+  type: string // the column type. eg: "uuid"
+  flags?: string[] // any special flags for the column. eg: ["key"]
+  type_modifier?: number // the type modifier. eg: 4294967295
+}[]
+
+type BaseValue = null | string | number | boolean
+type RecordValue = BaseValue | BaseValue[]
+
+type Record = {
+  [key: string]: RecordValue
+}
+
+/**
+ * Takes an array of columns and an object of string values then converts each string value
+ * to its mapped type.
+ *
+ * @param {{name: String, type: String}[]} columns
+ * @param {Object} record
+ * @param {Object} options The map of various options that can be applied to the mapper
+ * @param {Array} options.skipTypes The array of types that should not be converted
+ *
+ * @example convertChangeData([{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age:'33'}, {})
+ * //=>{ first_name: 'Paul', age: 33 }
+ */
+export const convertChangeData = (
+  columns: Columns,
+  record: Record | null,
+  options: { skipTypes?: string[] } = {}
+): Record => {
+  const skipTypes = options.skipTypes ?? []
+
+  if (!record) {
+    return {}
+  }
+
+  return Object.keys(record).reduce((acc, rec_key) => {
+    acc[rec_key] = convertColumn(rec_key, columns, record, skipTypes)
+    return acc
+  }, {} as Record)
+}
+
+/**
+ * Converts the value of an individual column.
+ *
+ * @param {String} columnName The column that you want to convert
+ * @param {{name: String, type: String}[]} columns All of the columns
+ * @param {Object} record The map of string values
+ * @param {Array} skipTypes An array of types that should not be converted
+ * @return {object} Useless information
+ *
+ * @example convertColumn('age', [{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age: '33'}, [])
+ * //=> 33
+ * @example convertColumn('age', [{name: 'first_name', type: 'text'}, {name: 'age', type: 'int4'}], {first_name: 'Paul', age: '33'}, ['int4'])
+ * //=> "33"
+ */
+export const convertColumn = (
+  columnName: string,
+  columns: Columns,
+  record: Record,
+  skipTypes: string[]
+): RecordValue => {
+  const column = columns.find((x) => x.name === columnName)
+  const colType = column?.type
+  const value = record[columnName]
+
+  if (colType && !skipTypes.includes(colType)) {
+    return convertCell(colType, value)
+  }
+
+  return noop(value)
+}
+
+/**
+ * If the value of the cell is `null`, returns null.
+ * Otherwise converts the string value to the correct type.
+ * @param {String} type A postgres column type
+ * @param {String} value The cell value
+ *
+ * @example convertCell('bool', 't')
+ * //=> true
+ * @example convertCell('int8', '10')
+ * //=> 10
+ * @example convertCell('_int4', '{1,2,3,4}')
+ * //=> [1,2,3,4]
+ */
+export const convertCell = (type: string, value: RecordValue): RecordValue => {
+  // if data type is an array
+  if (type.charAt(0) === '_') {
+    const dataType = type.slice(1, type.length)
+    return toArray(value, dataType)
+  }
+
+  // If not null, convert to correct type.
+  switch (type) {
+    case PostgresTypes.bool:
+      return toBoolean(value)
+    case PostgresTypes.float4:
+    case PostgresTypes.float8:
+    case PostgresTypes.int2:
+    case PostgresTypes.int4:
+    case PostgresTypes.int8:
+    case PostgresTypes.numeric:
+    case PostgresTypes.oid:
+      return toNumber(value)
+    case PostgresTypes.json:
+    case PostgresTypes.jsonb:
+      return toJson(value)
+    case PostgresTypes.timestamp:
+      return toTimestampString(value) // Format to be consistent with PostgREST
+    case PostgresTypes.abstime: // To allow users to cast it based on Timezone
+    case PostgresTypes.date: // To allow users to cast it based on Timezone
+    case PostgresTypes.daterange:
+    case PostgresTypes.int4range:
+    case PostgresTypes.int8range:
+    case PostgresTypes.money:
+    case PostgresTypes.reltime: // To allow users to cast it based on Timezone
+    case PostgresTypes.text:
+    case PostgresTypes.time: // To allow users to cast it based on Timezone
+    case PostgresTypes.timestamptz: // To allow users to cast it based on Timezone
+    case PostgresTypes.timetz: // To allow users to cast it based on Timezone
+    case PostgresTypes.tsrange:
+    case PostgresTypes.tstzrange:
+      return noop(value)
+    default:
+      // Return the value for remaining types
+      return noop(value)
+  }
+}
+
+const noop = (value: RecordValue): RecordValue => {
+  return value
+}
+export const toBoolean = (value: RecordValue): RecordValue => {
+  switch (value) {
+    case 't':
+      return true
+    case 'f':
+      return false
+    default:
+      return value
+  }
+}
+export const toNumber = (value: RecordValue): RecordValue => {
+  if (typeof value === 'string') {
+    const parsedValue = parseFloat(value)
+    if (!Number.isNaN(parsedValue)) {
+      return parsedValue
+    }
+  }
+  return value
+}
+export const toJson = (value: RecordValue): RecordValue => {
+  if (typeof value === 'string') {
+    try {
+      return JSON.parse(value)
+    } catch {
+      return value
+    }
+  }
+  return value
+}
+
+/**
+ * Converts a Postgres Array into a native JS array
+ *
+ * @example toArray('{}', 'int4')
+ * //=> []
+ * @example toArray('{"[2021-01-01,2021-12-31)","(2021-01-01,2021-12-32]"}', 'daterange')
+ * //=> ['[2021-01-01,2021-12-31)', '(2021-01-01,2021-12-32]']
+ * @example toArray([1,2,3,4], 'int4')
+ * //=> [1,2,3,4]
+ */
+export const toArray = (value: RecordValue, type: string): RecordValue => {
+  if (typeof value !== 'string') {
+    return value
+  }
+
+  const lastIdx = value.length - 1
+  const closeBrace = value[lastIdx]
+  const openBrace = value[0]
+
+  // Confirm value is a Postgres array by checking curly brackets
+  if (openBrace === '{' && closeBrace === '}') {
+    let arr
+    const valTrim = value.slice(1, lastIdx)
+
+    // TODO: find a better solution to separate Postgres array data
+    try {
+      arr = JSON.parse('[' + valTrim + ']')
+    } catch (_) {
+      // WARNING: splitting on comma does not cover all edge cases
+      arr = valTrim ? valTrim.split(',') : []
+    }
+
+    return arr.map((val: BaseValue) => convertCell(type, val))
+  }
+
+  return value
+}
+
+/**
+ * Fixes timestamp to be ISO-8601. Swaps the space between the date and time for a 'T'
+ * See https://github.com/supabase/supabase/issues/18
+ *
+ * @example toTimestampString('2019-09-10 00:00:00')
+ * //=> '2019-09-10T00:00:00'
+ */
+export const toTimestampString = (value: RecordValue): RecordValue => {
+  if (typeof value === 'string') {
+    return value.replace(' ', 'T')
+  }
+
+  return value
+}
+
+export const httpEndpointURL = (socketUrl: string): string => {
+  const wsUrl = new URL(socketUrl)
+
+  wsUrl.protocol = wsUrl.protocol.replace(/^ws/i, 'http')
+
+  wsUrl.pathname = wsUrl.pathname
+    .replace(/\/+$/, '') // remove all trailing slashes
+    .replace(/\/socket\/websocket$/i, '') // remove the socket/websocket path
+    .replace(/\/socket$/i, '') // remove the socket path
+    .replace(/\/websocket$/i, '') // remove the websocket path
+
+  if (wsUrl.pathname === '' || wsUrl.pathname === '/') {
+    wsUrl.pathname = '/api/broadcast'
+  } else {
+    wsUrl.pathname = wsUrl.pathname + '/api/broadcast'
+  }
+
+  return wsUrl.href
+}

package/src/lib/version.ts

@@ -0,0 +1,7 @@
+// Generated automatically during releases by scripts/update-version-files.ts
+// This file provides runtime access to the package version for:
+// - HTTP request headers (e.g., X-Client-Info header for API requests)
+// - Debugging and support (identifying which version is running)
+// - Telemetry and logging (version reporting in errors/analytics)
+// - Ensuring build artifacts match the published package version
+export const version = '2.99.3'