@supabase/phoenix 0.1.0

package/assets/js/phoenix/push.js

@@ -0,0 +1,134 @@
+/**
+ * @import Channel from "./channel"
+ * @import { ChannelEvent } from "./types"
+ */
+export default class Push {
+  /**
+   * Initializes the Push
+   * @param {Channel} channel - The Channel
+   * @param {ChannelEvent} event - The event, for example `"phx_join"`
+   * @param {() => Record<string, unknown>} payload - The payload, for example `{user_id: 123}`
+   * @param {number} timeout - The push timeout in milliseconds
+   */
+  constructor(channel, event, payload, timeout){
+    /** @type{Channel} */
+    this.channel = channel
+    /** @type{ChannelEvent} */
+    this.event = event
+    /** @type{() => Record<string, unknown>} */
+    this.payload = payload || function (){ return {} }
+    this.receivedResp = null
+    /** @type{number} */
+    this.timeout = timeout
+    /** @type{(ReturnType<typeof setTimeout>) | null} */
+    this.timeoutTimer = null
+    /** @type{{status: string; callback: (response: any) => void}[]} */
+    this.recHooks = []
+    /** @type{boolean} */
+    this.sent = false
+    /** @type{string | null | undefined} */
+    this.ref = undefined
+  }
+
+  /**
+   *
+   * @param {number} timeout
+   */
+  resend(timeout){
+    this.timeout = timeout
+    this.reset()
+    this.send()
+  }
+
+  /**
+   *
+   */
+  send(){
+    if(this.hasReceived("timeout")){ return }
+    this.startTimeout()
+    this.sent = true
+    this.channel.socket.push({
+      topic: this.channel.topic,
+      event: this.event,
+      payload: this.payload(),
+      ref: this.ref,
+      join_ref: this.channel.joinRef()
+    })
+  }
+
+  /**
+   *
+   * @param {string} status
+   * @param {(response: any) => void} callback
+   */
+  receive(status, callback){
+    if(this.hasReceived(status)){
+      callback(this.receivedResp.response)
+    }
+
+    this.recHooks.push({status, callback})
+    return this
+  }
+
+  reset(){
+    this.cancelRefEvent()
+    this.ref = null
+    this.refEvent = null
+    this.receivedResp = null
+    this.sent = false
+  }
+
+  destroy(){
+    this.cancelRefEvent()
+    this.cancelTimeout()
+  }
+
+  /**
+   * @private
+   */
+  matchReceive({status, response, _ref}){
+    this.recHooks.filter(h => h.status === status)
+      .forEach(h => h.callback(response))
+  }
+
+  /**
+   * @private
+   */
+  cancelRefEvent(){
+    if(!this.refEvent){ return }
+    this.channel.off(this.refEvent)
+  }
+
+  cancelTimeout(){
+    clearTimeout(this.timeoutTimer)
+    this.timeoutTimer = null
+  }
+
+  startTimeout(){
+    if(this.timeoutTimer){ this.cancelTimeout() }
+    this.ref = this.channel.socket.makeRef()
+    this.refEvent = this.channel.replyEventName(this.ref)
+
+    this.channel.on(this.refEvent, payload => {
+      this.cancelRefEvent()
+      this.cancelTimeout()
+      this.receivedResp = payload
+      this.matchReceive(payload)
+    })
+
+    this.timeoutTimer = setTimeout(() => {
+      this.trigger("timeout", {})
+    }, this.timeout)
+  }
+
+  /**
+   * @private
+   */
+  hasReceived(status){
+    return this.receivedResp && this.receivedResp.status === status
+  }
+
+  trigger(status, response){
+    this.channel.trigger(this.refEvent, {status, response})
+  }
+}

package/assets/js/phoenix/serializer.js

@@ -0,0 +1,133 @@
+/* The default serializer for encoding and decoding messages */
+import {
+  CHANNEL_EVENTS
+} from "./constants"
+
+/**
+ * @import { Message } from "./types"
+ */
+
+export default {
+  HEADER_LENGTH: 1,
+  META_LENGTH: 4,
+  KINDS: {push: 0, reply: 1, broadcast: 2},
+
+  /**
+  * @template T
+  * @param {Message<Record<string, any>>} msg
+  * @param {(msg: ArrayBuffer | string) => T} callback
+  * @returns {T}
+  */
+  encode(msg, callback){
+    if(msg.payload.constructor === ArrayBuffer){
+      return callback(this.binaryEncode(msg))
+    } else {
+      let payload = [msg.join_ref, msg.ref, msg.topic, msg.event, msg.payload]
+      return callback(JSON.stringify(payload))
+    }
+  },
+
+  /**
+  * @template T
+  * @param {ArrayBuffer | string} rawPayload
+  * @param {(msg: Message<unknown>) => T} callback
+  * @returns {T}
+  */
+  decode(rawPayload, callback){
+    if(rawPayload.constructor === ArrayBuffer){
+      return callback(this.binaryDecode(rawPayload))
+    } else {
+      let [join_ref, ref, topic, event, payload] = JSON.parse(rawPayload)
+      return callback({join_ref, ref, topic, event, payload})
+    }
+  },
+
+  /** @private */
+  binaryEncode(message){
+    let {join_ref, ref, event, topic, payload} = message
+    let metaLength = this.META_LENGTH + join_ref.length + ref.length + topic.length + event.length
+    let header = new ArrayBuffer(this.HEADER_LENGTH + metaLength)
+    let view = new DataView(header)
+    let offset = 0
+
+    view.setUint8(offset++, this.KINDS.push) // kind
+    view.setUint8(offset++, join_ref.length)
+    view.setUint8(offset++, ref.length)
+    view.setUint8(offset++, topic.length)
+    view.setUint8(offset++, event.length)
+    Array.from(join_ref, 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(event, char => view.setUint8(offset++, char.charCodeAt(0)))
+
+    var combined = new Uint8Array(header.byteLength + payload.byteLength)
+    combined.set(new Uint8Array(header), 0)
+    combined.set(new Uint8Array(payload), header.byteLength)
+
+    return combined.buffer
+  },
+
+  /**
+  * @private
+  */
+  binaryDecode(buffer){
+    let view = new DataView(buffer)
+    let kind = view.getUint8(0)
+    let decoder = new TextDecoder()
+    switch(kind){
+      case this.KINDS.push: return this.decodePush(buffer, view, decoder)
+      case this.KINDS.reply: return this.decodeReply(buffer, view, decoder)
+      case this.KINDS.broadcast: return this.decodeBroadcast(buffer, view, decoder)
+    }
+  },
+
+  /** @private */
+  decodePush(buffer, view, decoder){
+    let joinRefSize = view.getUint8(1)
+    let topicSize = view.getUint8(2)
+    let eventSize = view.getUint8(3)
+    let offset = this.HEADER_LENGTH + this.META_LENGTH - 1 // pushes have no ref
+    let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize))
+    offset = offset + joinRefSize
+    let topic = decoder.decode(buffer.slice(offset, offset + topicSize))
+    offset = offset + topicSize
+    let event = decoder.decode(buffer.slice(offset, offset + eventSize))
+    offset = offset + eventSize
+    let data = buffer.slice(offset, buffer.byteLength)
+    return {join_ref: joinRef, ref: null, topic: topic, event: event, payload: data}
+  },
+
+  /** @private */
+  decodeReply(buffer, view, decoder){
+    let joinRefSize = view.getUint8(1)
+    let refSize = view.getUint8(2)
+    let topicSize = view.getUint8(3)
+    let eventSize = view.getUint8(4)
+    let offset = this.HEADER_LENGTH + this.META_LENGTH
+    let joinRef = decoder.decode(buffer.slice(offset, offset + joinRefSize))
+    offset = offset + joinRefSize
+    let ref = decoder.decode(buffer.slice(offset, offset + refSize))
+    offset = offset + refSize
+    let topic = decoder.decode(buffer.slice(offset, offset + topicSize))
+    offset = offset + topicSize
+    let event = decoder.decode(buffer.slice(offset, offset + eventSize))
+    offset = offset + eventSize
+    let data = buffer.slice(offset, buffer.byteLength)
+    let payload = {status: event, response: data}
+    return {join_ref: joinRef, ref: ref, topic: topic, event: CHANNEL_EVENTS.reply, payload: payload}
+  },
+
+  /** @private */
+  decodeBroadcast(buffer, view, decoder){
+    let topicSize = view.getUint8(1)
+    let eventSize = view.getUint8(2)
+    let offset = this.HEADER_LENGTH + 2
+    let topic = decoder.decode(buffer.slice(offset, offset + topicSize))
+    offset = offset + topicSize
+    let event = decoder.decode(buffer.slice(offset, offset + eventSize))
+    offset = offset + eventSize
+    let data = buffer.slice(offset, buffer.byteLength)
+
+    return {join_ref: null, ref: null, topic: topic, event: event, payload: data}
+  }
+}