wsocket-io 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: a49398de6e4dfd18df620b3e3fb1d367906fd9a13e4977cddf16e641b8f12b3b
+  data.tar.gz: a750836ba920e6a68b76bd9855ceaa6206158ae24f99fea80b3ae5d4ca07e0ee
+SHA512:
+  metadata.gz: 57566fcd09e83871eabb16ef9b5d4cd11f4440a9a2e872968c86d48f082bb1ef575ad4a3a567a2f3838ac4d45dea0e5f8f804af7cdf1fc6b3ad53bd06225dfdd
+  data.tar.gz: 1a98eb61c17b8c86c341dc4d4dde05945bc4761e03bbd8b269636c7d5b0a9b8de855f6bc04cba8aeb50ad8b7408d9fae845549336254a177417c1e8db979e842

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 wSocket
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,105 @@
+# wSocket SDK for Ruby
+
+Official Ruby SDK for wSocket — realtime pub/sub, presence, history, and push notifications.
+
+## Installation
+
+Add to your Gemfile:
+
+```ruby
+gem 'wsocket-io'
+```
+
+Then run:
+
+```bash
+bundle install
+```
+
+Or install directly:
+
+```bash
+gem install wsocket-io
+```
+
+## Quick Start
+
+```ruby
+require 'wsocket_io'
+
+client = WSocketIO::Client.new('wss://node00.wsocket.online', 'your-api-key')
+
+client.on_connect { puts 'Connected!' }
+
+client.connect
+
+channel = client.pubsub.channel('chat')
+
+channel.subscribe do |data, meta|
+  puts "Received: #{data}"
+end
+
+channel.publish({ text: 'Hello from Ruby!' })
+```
+
+## Presence
+
+```ruby
+channel = client.pubsub.channel('room')
+
+channel.presence.enter(data: { name: 'Alice' })
+
+channel.presence.on_enter do |member|
+  puts "#{member.client_id} entered"
+end
+
+channel.presence.on_leave do |member|
+  puts "#{member.client_id} left"
+end
+
+channel.presence.get
+channel.presence.on_members do |members|
+  puts "Online: #{members.length}"
+end
+```
+
+## History
+
+```ruby
+channel.history(limit: 50)
+channel.on_history do |result|
+  result.messages.each do |msg|
+    puts "#{msg.publisher_id}: #{msg.data}"
+  end
+end
+```
+
+## Push Notifications
+
+```ruby
+push = WSocketIO::PushClient.new(
+  base_url: 'https://node00.wsocket.online',
+  token: 'secret',
+  app_id: 'app1'
+)
+
+# Register FCM device
+push.register_fcm(device_token: fcm_token, member_id: 'user-123')
+
+# Send to a member
+push.send_to_member('user-123', payload: {
+  title: 'New message',
+  body: 'You have a new message'
+})
+
+# Broadcast
+push.broadcast(payload: { title: 'Announcement', body: 'Server update' })
+```
+
+## Requirements
+
+- Ruby 3.0+
+
+## License
+
+MIT

data/lib/wsocket_io.rb

@@ -0,0 +1,405 @@
+# frozen_string_literal: true
+
+# wSocket Ruby SDK — Realtime Pub/Sub client with Presence, History, and Push.
+#
+# Usage:
+#   client = WSocketIO::Client.new('ws://localhost:9001', 'your-api-key')
+#   client.connect
+#   ch = client.pubsub.channel('chat')
+#   ch.subscribe { |data, meta| puts data }
+#   ch.publish({ text: 'hello' })
+
+require 'json'
+require 'websocket-client-simple'
+require 'net/http'
+require 'uri'
+require 'securerandom'
+require 'base64'
+
+module WSocketIO
+  # ─── Types ──────────────────────────────────────────────────
+
+  MessageMeta = Struct.new(:id, :channel, :timestamp, keyword_init: true)
+
+  PresenceMember = Struct.new(:client_id, :data, :joined_at, keyword_init: true) do
+    def initialize(client_id: '', data: nil, joined_at: 0)
+      super
+    end
+  end
+
+  HistoryMessage = Struct.new(:id, :channel, :data, :publisher_id, :timestamp, :sequence, keyword_init: true) do
+    def initialize(id: '', channel: '', data: nil, publisher_id: '', timestamp: 0, sequence: 0)
+      super
+    end
+  end
+
+  HistoryResult = Struct.new(:channel, :messages, :has_more, keyword_init: true) do
+    def initialize(channel: '', messages: [], has_more: false)
+      super
+    end
+  end
+
+  Options = Struct.new(:auto_reconnect, :max_reconnect_attempts, :reconnect_delay, :token, :recover, keyword_init: true) do
+    def initialize(auto_reconnect: true, max_reconnect_attempts: 10, reconnect_delay: 1.0, token: nil, recover: true)
+      super
+    end
+  end
+
+  # ─── Presence ───────────────────────────────────────────────
+
+  class Presence
+    def initialize(channel_name, send_fn)
+      @channel_name = channel_name
+      @send_fn = send_fn
+      @enter_cbs = []
+      @leave_cbs = []
+      @update_cbs = []
+      @members_cbs = []
+    end
+
+    def enter(data: nil)
+      @send_fn.call({ action: 'presence.enter', channel: @channel_name, data: data })
+      self
+    end
+
+    def leave
+      @send_fn.call({ action: 'presence.leave', channel: @channel_name })
+      self
+    end
+
+    def update(data)
+      @send_fn.call({ action: 'presence.update', channel: @channel_name, data: data })
+      self
+    end
+
+    def get
+      @send_fn.call({ action: 'presence.get', channel: @channel_name })
+      self
+    end
+
+    def on_enter(&block) = (@enter_cbs << block; self)
+    def on_leave(&block) = (@leave_cbs << block; self)
+    def on_update(&block) = (@update_cbs << block; self)
+    def on_members(&block) = (@members_cbs << block; self)
+
+    def handle_event(action, data)
+      case action
+      when 'presence.enter'
+        m = parse_member(data)
+        @enter_cbs.each { |cb| cb.call(m) }
+      when 'presence.leave'
+        m = parse_member(data)
+        @leave_cbs.each { |cb| cb.call(m) }
+      when 'presence.update'
+        m = parse_member(data)
+        @update_cbs.each { |cb| cb.call(m) }
+      when 'presence.members'
+        members = (data['members'] || []).map { |d| parse_member(d) }
+        @members_cbs.each { |cb| cb.call(members) }
+      end
+    end
+
+    private
+
+    def parse_member(d)
+      PresenceMember.new(
+        client_id: d['clientId'] || '',
+        data: d['data'],
+        joined_at: d['joinedAt'] || 0
+      )
+    end
+  end
+
+  # ─── Channel ────────────────────────────────────────────────
+
+  class Channel
+    attr_reader :name, :presence
+
+    def initialize(name, send_fn)
+      @name = name
+      @send_fn = send_fn
+      @message_cbs = []
+      @history_cbs = []
+      @presence = Presence.new(name, send_fn)
+    end
+
+    def subscribe(&callback)
+      @message_cbs << callback if callback
+      @send_fn.call({ action: 'subscribe', channel: @name })
+      self
+    end
+
+    def unsubscribe
+      @send_fn.call({ action: 'unsubscribe', channel: @name })
+      @message_cbs.clear
+      self
+    end
+
+    def publish(data, persist: nil)
+      msg = { action: 'publish', channel: @name, data: data, id: SecureRandom.uuid }
+      msg[:persist] = persist unless persist.nil?
+      @send_fn.call(msg)
+      self
+    end
+
+    def history(limit: nil, before: nil, after: nil, direction: nil)
+      opts = { action: 'history', channel: @name }
+      opts[:limit] = limit if limit
+      opts[:before] = before if before
+      opts[:after] = after if after
+      opts[:direction] = direction if direction
+      @send_fn.call(opts)
+      self
+    end
+
+    def on_history(&block)
+      @history_cbs << block
+      self
+    end
+
+    def handle_message(data, meta)
+      @message_cbs.each { |cb| cb.call(data, meta) }
+    end
+
+    def handle_history(result)
+      @history_cbs.each { |cb| cb.call(result) }
+    end
+  end
+
+  # ─── PubSub Namespace ──────────────────────────────────────
+
+  class PubSubNamespace
+    def initialize(client)
+      @client = client
+    end
+
+    def channel(name)
+      @client.channel(name)
+    end
+  end
+
+  # ─── Push Client ────────────────────────────────────────────
+
+  class PushClient
+    def initialize(base_url:, token:, app_id:)
+      @base_url = base_url
+      @token = token
+      @app_id = app_id
+    end
+
+    def register_fcm(device_token:, member_id:)
+      post('register', { memberId: member_id, platform: 'fcm', subscription: { deviceToken: device_token } })
+    end
+
+    def register_apns(device_token:, member_id:)
+      post('register', { memberId: member_id, platform: 'apns', subscription: { deviceToken: device_token } })
+    end
+
+    def send_to_member(member_id, payload:)
+      post('send', { memberId: member_id, payload: payload })
+    end
+
+    def broadcast(payload:)
+      post('broadcast', { payload: payload })
+    end
+
+    def unregister(member_id, platform: nil)
+      body = { memberId: member_id }
+      body[:platform] = platform if platform
+      uri = URI("#{@base_url}/api/push/unregister")
+      req = Net::HTTP::Delete.new(uri, headers)
+      req.body = body.to_json
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(req) }
+    end
+
+    private
+
+    def headers
+      { 'Authorization' => "Bearer #{@token}", 'X-App-Id' => @app_id, 'Content-Type' => 'application/json' }
+    end
+
+    def post(path, body)
+      uri = URI("#{@base_url}/api/push/#{path}")
+      req = Net::HTTP::Post.new(uri, headers)
+      req.body = body.to_json
+      Net::HTTP.start(uri.hostname, uri.port, use_ssl: uri.scheme == 'https') { |http| http.request(req) }
+    end
+  end
+
+  # ─── Client ─────────────────────────────────────────────────
+
+  class Client
+    attr_reader :pubsub
+
+    def initialize(url, api_key, options = Options.new)
+      @url = url
+      @api_key = api_key
+      @options = options
+      @channels = {}
+      @subscribed_channels = {}
+      @last_message_ts = 0
+      @reconnect_attempts = 0
+      @connected = false
+      @ws = nil
+
+      @on_connect_cbs = []
+      @on_disconnect_cbs = []
+      @on_error_cbs = []
+
+      @pubsub = PubSubNamespace.new(self)
+    end
+
+    def on_connect(&block) = (@on_connect_cbs << block; self)
+    def on_disconnect(&block) = (@on_disconnect_cbs << block; self)
+    def on_error(&block) = (@on_error_cbs << block; self)
+    def connected? = @connected
+
+    def connect
+      ws_url = @url.dup
+      ws_url += @url.include?('?') ? '&' : '?'
+      ws_url += "key=#{@api_key}"
+      ws_url += "&token=#{@options.token}" if @options.token
+
+      client = self
+      @ws = WebSocket::Client::Simple.connect(ws_url) do |ws|
+        ws.on :open do
+          client.send(:handle_open)
+        end
+
+        ws.on :message do |msg|
+          client.send(:handle_raw_message, msg.data)
+        end
+
+        ws.on :close do |e|
+          client.send(:handle_close, e)
+        end
+
+        ws.on :error do |e|
+          client.send(:handle_error, e)
+        end
+      end
+
+      self
+    end
+
+    def disconnect
+      @connected = false
+      @ws&.close
+    end
+
+    def channel(name)
+      @channels[name] ||= Channel.new(name, method(:send_msg))
+    end
+
+    def configure_push(base_url:, token:, app_id:)
+      PushClient.new(base_url: base_url, token: token, app_id: app_id)
+    end
+
+    private
+
+    def send_msg(msg)
+      return unless @connected
+
+      hash = stringify_keys(msg)
+      @ws&.send(hash.to_json)
+    end
+
+    def handle_open
+      @connected = true
+      @reconnect_attempts = 0
+
+      if @options.recover && !@subscribed_channels.empty? && @last_message_ts > 0
+        resume_data = { channels: @subscribed_channels.keys, since: @last_message_ts }
+        token = Base64.urlsafe_encode64(resume_data.to_json, padding: false)
+        send_msg({ action: 'resume', token: token })
+      else
+        @subscribed_channels.each_key do |ch|
+          send_msg({ action: 'subscribe', channel: ch })
+        end
+      end
+
+      @on_connect_cbs.each(&:call)
+    end
+
+    def handle_raw_message(raw)
+      msg = JSON.parse(raw)
+      action = msg['action']
+      return unless action
+
+      channel_name = msg['channel']
+
+      case action
+      when 'message'
+        ch = channel_name && @channels[channel_name]
+        return unless ch
+
+        ts = msg['timestamp']&.to_i || (Time.now.to_f * 1000).to_i
+        @last_message_ts = ts if ts > @last_message_ts
+        meta = MessageMeta.new(id: msg['id'] || '', channel: channel_name, timestamp: ts)
+        ch.handle_message(msg['data'], meta)
+
+      when 'subscribed'
+        @subscribed_channels[channel_name] = true if channel_name
+
+      when 'unsubscribed'
+        @subscribed_channels.delete(channel_name) if channel_name
+
+      when 'history'
+        ch = channel_name && @channels[channel_name]
+        return unless ch
+
+        messages = (msg['messages'] || []).map do |m|
+          HistoryMessage.new(
+            id: m['id'] || '', channel: channel_name,
+            data: m['data'], publisher_id: m['publisherId'] || '',
+            timestamp: m['timestamp']&.to_i || 0,
+            sequence: m['sequence']&.to_i || 0
+          )
+        end
+        ch.handle_history(HistoryResult.new(channel: channel_name, messages: messages, has_more: msg['hasMore'] == true))
+
+      when 'presence.enter', 'presence.leave', 'presence.update', 'presence.members'
+        ch = channel_name && @channels[channel_name]
+        return unless ch
+
+        ch.presence.handle_event(action, msg)
+
+      when 'error'
+        err = msg['error'] || 'Unknown error'
+        @on_error_cbs.each { |cb| cb.call(RuntimeError.new(err)) }
+      end
+    rescue StandardError => e
+      @on_error_cbs.each { |cb| cb.call(e) }
+    end
+
+    def handle_close(_event)
+      @connected = false
+      @on_disconnect_cbs.each { |cb| cb.call(1000) }
+      maybe_reconnect
+    end
+
+    def handle_error(error)
+      @connected = false
+      @on_error_cbs.each { |cb| cb.call(error) }
+      maybe_reconnect
+    end
+
+    def maybe_reconnect
+      return unless @options.auto_reconnect
+      return if @reconnect_attempts >= @options.max_reconnect_attempts
+
+      @reconnect_attempts += 1
+      delay = @options.reconnect_delay * @reconnect_attempts
+      Thread.new do
+        sleep(delay)
+        connect unless @connected
+      end
+    end
+
+    def stringify_keys(hash)
+      hash.transform_keys(&:to_s).transform_values do |v|
+        v.is_a?(Hash) ? stringify_keys(v) : v
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,74 @@
+--- !ruby/object:Gem::Specification
+name: wsocket-io
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- wSocket
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2026-03-06 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket-client-simple
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.6'
+description: Official Ruby SDK for wSocket — realtime pub/sub, presence, history,
+  and push notifications.
+email: sdk@wsocket.io
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/wsocket_io.rb
+homepage: https://github.com/wsocket-io/sdk-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '3.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.3.5
+signing_key: 
+specification_version: 4
+summary: wSocket SDK for Ruby
+test_files: []