isomorfeus-transport 1.0.0.zeta23 → 1.0.0.zeta24

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f880aa11773aa387acfd1e8bcee0b3dc1678c6657341a4dff9612b4e0cbd73d6
-  data.tar.gz: a17830e51f92e94ea20b1e059dcb6832578a6688583e1579edc1ccbc32d51729
+  metadata.gz: 57acf05b4a459474ca19bac1e618d668107a680eda369801eac39ed8da92fa0d
+  data.tar.gz: 9c6ec632e4c577d2c6c3eacf361c9454c14cbc7f279846513f0445be93b1ae54
 SHA512:
-  metadata.gz: 8cc684ec49a19d7aedb5f1f59c284e78ae426bd9ff03f33874f07a37bf5085f902b803049efebb24ceea982e71ae97c23b59ae323fe510d8d97e09aeb6fab74a
-  data.tar.gz: 102b5ff34f5127d81ed4cd026b02b7beb87f9c595b2d5cfe49a4a42a675a8147cc9faff7ae5797293d3bf5982e86c5b1321e06a092acf7c195cf5374c4facb52
+  metadata.gz: c76f4b1de79e6a3ee13ccdca85f6c8ffc31b778791970b631d33adee9f28b2a43885dfdf75ff36f674d215700ebfb4e853b44692350581c56b8bdf7d85c3c39e
+  data.tar.gz: c085ed5a02a6d7040b5e0ca45dd7ec5225ccb39702956953124f2c7f11662ffd1dd9202d733136c9d5d890213c1b6df8c88fa68c648cc0ee74d27a553b0ee7d7

data/README.md

@@ -32,5 +32,5 @@ Server only:
 
 ## Usage
 
-- [Authentication and Current User](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-policy/docs/authentication.md)
-- [Channels (PubSub)](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-policy/docs/channels.md)
+- [Authentication and Current User](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-transport/docs/authentication.md)
+- [Channels (PubSub)](https://github.com/isomorfeus/isomorfeus-project/blob/master/ruby/isomorfeus-transport/docs/channels.md)

data/lib/isomorfeus-transport.rb

@@ -2,7 +2,6 @@ require 'isomorfeus-policy'
 require 'lucid_authentication/mixin'
 if RUBY_ENGINE == 'opal'
   require 'json'
-  require 'isomorfeus/execution_environment'
   require 'isomorfeus/transport/version'
   require 'isomorfeus/transport/config'
   require 'isomorfeus/transport/request_agent'
@@ -38,7 +37,7 @@ else
   require 'isomorfeus/transport/server_processor'
   require 'isomorfeus/transport/server_socket_processor'
   require 'isomorfeus/transport/websocket'
-
+  require 'isomorfeus/transport'
   require 'isomorfeus/transport/rack_middleware'
   require 'isomorfeus/transport/middlewares'
 

data/lib/isomorfeus/transport.rb

@@ -4,10 +4,6 @@ module Isomorfeus
       if RUBY_ENGINE == 'opal'
         attr_accessor :socket
 
-        def delay(ms = 1000, &block)
-          `setTimeout(#{block.to_n}, #{ms})`
-        end
-
         def init
           @requests_in_progress = { requests: {}, agent_ids: {} }
           @socket = nil
@@ -32,7 +28,7 @@ module Isomorfeus
           @socket = Isomorfeus::Transport::Websocket.new(ws_url)
           @socket.on_error do
             @socket.close
-            delay 1000 do
+            after 1000 do
               Isomorfeus::Transport.promise_connect
             end
           end
@@ -99,14 +95,14 @@ module Isomorfeus
             begin
               @socket.send(`JSON.stringify(#{{request: { agent_ids: { agent.id => request }}}.to_n})`)
               agent.sent = true
-              delay(Isomorfeus.on_ssr? ? 8000 : 20000) do
+              after(Isomorfeus.on_ssr? ? 8000 : 20000) do
                 unless agent.promise.realized?
                   agent.promise.reject({agent_response: { error: 'Request timeout!' }, full_response: {}})
                 end
               end
             rescue
               @socket.close
-              delay 5000 do
+              after 5000 do
                 Isomorfeus::Transport.promise_connect
               end
             end
@@ -114,51 +110,41 @@ module Isomorfeus
           agent.promise
         end
 
-        def send_notification(channel_class, channel, message)
+        def send_message(channel_class, channel, message)
           Isomorfeus.raise_error(message: 'No socket!') unless @socket
-          @socket.send(`JSON.stringify(#{{notification: { class: channel_class.name, channel: channel, message: message}}.to_n})`)
+          @socket.send(`JSON.stringify(#{{ notification: { class: channel_class.name, channel: channel, message: message }}.to_n})`)
           true
         end
 
-        def subscribe(channel_class, channel, &block)
-          request = { subscribe: true, class: channel_class.name, channel: channel }
+        def promise_subscribe(channel_class_name, channel)
+          request = { subscribe: true, class: channel_class_name, channel: channel }
           if request_in_progress?(request)
             agent = get_agent_for_request_in_progress(request)
           else
             agent = Isomorfeus::Transport::RequestAgent.new(request)
             register_request_in_progress(request, agent.id)
             Isomorfeus.raise_error(message: 'No socket!') unless @socket
-            @socket.send(`JSON.stringify(#{{subscribe: { agent_ids: { agent.id => request }}}.to_n})`)
+            @socket.send(`JSON.stringify(#{{ subscribe: { agent_ids: { agent.id => request }}}.to_n})`)
           end
           result_promise = agent.promise.then do |agent|
             agent.response
           end
-          if block_given?
-            result_promise = result_promise.then do |response|
-              block.call(response)
-            end
-          end
           result_promise
         end
 
-        def unsubscribe(channel_class, channel, &block)
-          request = { unsubscribe: true, class: channel_class.name, channel: channel }
+        def promise_unsubscribe(channel_class_name, channel)
+          request = { unsubscribe: true, class: channel_class_name, channel: channel }
           if request_in_progress?(request)
             agent = get_agent_for_request_in_progress(request)
           else
             agent = Isomorfeus::Transport::RequestAgent.new(request)
             register_request_in_progress(request, agent.id)
             Isomorfeus.raise_error(message: 'No socket!') unless @socket
-            @socket.send(`JSON.stringify(#{{unsubscribe: { agent_ids: { agent.id => request }}}.to_n})`)
+            @socket.send(`JSON.stringify(#{{ unsubscribe: { agent_ids: { agent.id => request }}}.to_n})`)
           end
           result_promise = agent.promise.then do |agent|
             agent.response
           end
-          if block_given?
-            result_promise = result_promise.then do |response|
-              block.call(response)
-            end
-          end
           result_promise
         end
 
@@ -189,23 +175,20 @@ module Isomorfeus
           @requests_in_progress[:requests].delete(request)
         end
       else # RUBY_ENGINE
-        def send_notification(channel_class, channel, message)
-          Thread.current[:isomorfeus_pub_sub_client].publish(Oj.dump({notification: { class: channel_class.name, channel: channel, message: message}}, mode: :strict))
+        def send_message(channel_class, channel, message)
+          channel_class_name = channel_class.name
+          Isomorfeus.pub_sub_client.publish("#{channel_class_name}_#{channel}", Oj.dump({notification: { class: channel_class_name, channel: channel, message: message}}, mode: :strict))
           true
         end
 
-        def subscribe(channel_class, channel, &block)
-          Thread.current[:isomorfeus_pub_sub_client].subscribe(channel)
-          result_promise = Promise.new
-          result_promise.resolve({ success: channel })
-          result_promise
+        def promise_subscribe(channel_class, channel, &block)
+          Isomorfeus.pub_sub_client.subscribe(channel)
+          Promise.new.resolve({ success: channel })
         end
 
-        def unsubscribe(channel_class, channel, &block)
-          Thread.current[:isomorfeus_pub_sub_client].unsubscribe(channel)
-          result_promise = Promise.new
-          result_promise.resolve({ success: channel })
-          result_promise
+        def promise_unsubscribe(channel_class, channel, &block)
+          Isomorfeus.pub_sub_client.unsubscribe(channel)
+          Promise.new.resolve({ success: channel })
         end
       end # RUBY_ENGINE
     end

data/lib/isomorfeus/transport/client_processor.rb

@@ -5,13 +5,18 @@ module Isomorfeus
         if json_hash.key?(:response)
           process_response(json_hash)
         elsif json_hash.key?(:notification)
-          process_notification(json_hash)
+          process_message(json_hash)
         end
       end
 
-      def self.process_notification(notification_hash)
-        processor_class = "::#{notification_hash[:notification][:class]}".constantize
-        processor_class.process_message(notification_hash[:notification][:channel], notification_hash[:notification][:message])
+      def self.process_message(message_hash)
+        processor_class_name = message_hash[:notification][:class]
+        Isomorfeus.raise_error(message: "Not a valid channel class #{processor_class_name}!") unless Isomorfeus.valid_channel_class_name?(processor_class_name)
+        processor_class = Isomorfeus.cached_channel_class(processor_class_name)
+        unless processor_class.respond_to?(:process_message)
+          Isomorfeus.raise_error(message: "Cannot process message, #{processor_class} must be a Channel and must have the on_message block defined!")
+        end
+        processor_class.process_message(message_hash[:notification][:message], message_hash[:notification][:error], message_hash[:notification][:channel])
       end
 
       def self.process_response(response_hash)
@@ -27,4 +32,4 @@ module Isomorfeus
       end
     end
   end
-end
+end

data/lib/isomorfeus/transport/config.rb

@@ -1,33 +1,65 @@
 module Isomorfeus
   # available settings
+  class << self
+    def cached_channel_classes
+      @cached_channel_classes ||= {}
+    end
+
+    def cached_channel_class(class_name)
+      return "::#{class_name}".constantize if Isomorfeus.development?
+      return cached_channel_classes[class_name] if cached_channel_classes.key?(class_name)
+      cached_channel_classes[class_name] = "::#{class_name}".constantize
+    end
+
+    def valid_channel_class_names
+      @valid_channel_class_names ||= Set.new
+    end
+
+    def add_valid_channel_class(klass)
+      valid_channel_class_names << raw_class_name(klass)
+    end
+
+    def raw_class_name(klass)
+      class_name = klass.name
+      class_name = class_name.split('>::').last if class_name.start_with?('#<')
+      class_name
+    end
+  end
 
   if RUBY_ENGINE == 'opal'
     add_client_option(:api_websocket_path)
     add_client_option(:cookie_eater_path)
     add_client_option(:transport_init_class_names, [])
 
-    def self.add_transport_init_class_name(init_class_name)
-      transport_init_class_names << init_class_name
-    end
+    class << self
+      def valid_channel_class_name?(class_name)
+        cached_channel_class(class_name) # because of autoloader
+        valid_channel_class_names.include?(class_name)
+      end
 
-    def self.current_user
-      @current_user ||= init_current_user
-    end
+      def add_transport_init_class_name(init_class_name)
+        transport_init_class_names << init_class_name
+      end
 
-    def self.init_current_user
-      if Isomorfeus.current_user_sid
-        Isomorfeus.instance_from_sid(Isomorfeus.current_user_sid)
-      else
-        Anonymous.new
+      def current_user
+        @current_user ||= init_current_user
+      end
+
+      def init_current_user
+        if Isomorfeus.current_user_sid
+          Isomorfeus.instance_from_sid(Isomorfeus.current_user_sid)
+        else
+          Anonymous.new
+        end
       end
-    end
 
-    def self.set_current_user(user)
-      if user
-        @current_user = user
-        Isomorfeus.current_user_sid = user.to_sid
-      else
-        @current_user = Anonymous.new
+      def set_current_user(user)
+        if user
+          @current_user = user
+          Isomorfeus.current_user_sid = user.to_sid
+        else
+          @current_user = Anonymous.new
+        end
       end
     end
   else
@@ -37,6 +69,10 @@ module Isomorfeus
       attr_accessor :session_store
       attr_accessor :cookie_dbm_path
 
+      def valid_channel_class_name?(class_name)
+        valid_channel_class_names.include?(class_name)
+      end
+
       def add_middleware(middleware)
         Isomorfeus.middlewares << middleware
       end
@@ -67,28 +103,6 @@ module Isomorfeus
         @middlewares ||= Set.new
       end
 
-      def cached_channel_classes
-        @cached_channel_classes ||= {}
-      end
-
-      def cached_channel_class(class_name)
-        return "::#{class_name}".constantize if Isomorfeus.development?
-        return cached_channel_classes[class_name] if cached_channel_classes.key?(class_name)
-        cached_channel_classes[class_name] = "::#{class_name}".constantize
-      end
-
-      def valid_channel_class_names
-        @valid_channel_class_names ||= Set.new
-      end
-
-      def valid_channel_class_name?(class_name)
-        valid_channel_class_names.include?(class_name)
-      end
-
-      def add_valid_channel_class(klass)
-        valid_channel_class_names << raw_class_name(klass)
-      end
-
       def valid_handler_class_names
         @valid_handler_class_names ||= Set.new
       end
@@ -133,12 +147,6 @@ module Isomorfeus
         cached_user_classes[class_name] = "::#{class_name}".constantize
       end
 
-      def raw_class_name(klass)
-        class_name = klass.name
-        class_name = class_name.split('>::').last if class_name.start_with?('#<')
-        class_name
-      end
-
       def current_user
         Thread.current[:isomorfeus_user]
       end

data/lib/isomorfeus/transport/server_processor.rb

@@ -29,26 +29,42 @@ module Isomorfeus
         elsif request.key?('notification')
           begin
             channel = request['notification']['channel']
-            class_name = request['notification']['class']
-
-            if Isomorfeus.valid_channel_class_name?(class_name) && channel
-              channel_class = Isomorfeus.cached_channel_class(class_name)
-              if channel_class && Isomorfeus.current_user.authorized?(channel_class, :send_message, channel)
-                Isomorfeus.pub_sub_client.publish(request['notification']['channel'], Oj.dump({ 'notification' => request['notification'] }, mode: :strict))
+            channel_class_name = request['notification']['class']
+            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
+              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
+              if channel_class && channel_class.valid_channel?(channel)
+                if Isomorfeus.current_user.authorized?(channel_class_name, :send_message, channel)
+                  allow_publish = if channel_class.server_is_processing_messages?(channel)
+                                    channel_class.server_process_message(request['notification']['message'], channel)
+                                  else
+                                    true
+                                  end
+                  if allow_publish == true
+                    Isomorfeus.pub_sub_client.publish("#{channel_class_name}_#{channel}", Oj.dump({ 'notification' => request['notification'] }, mode: :strict))
+                  else
+                    response_agent = OpenStruct.new
+                    response_agent.result = { notification: request['notification'].merge(error: 'Message cancelled!') }
+                    response_agent_array << response_agent
+                  end
+                else
+                  response_agent = OpenStruct.new
+                  response_agent.result = { notification: request['notification'].merge(error: 'Not authorized!') }
+                  response_agent_array << response_agent
+                end
               else
                 response_agent = OpenStruct.new
+                response_agent.result = { notification: request['notification'].merge(error: "Not a valid channel #{channel} for #{channel_class_name}!") }
                 response_agent_array << response_agent
-                response_agent.result = { response: { error: 'Not authorized!' }}
               end
             else
               response_agent = OpenStruct.new
+              response_agent.result = { notification: request['notification'].merge(error: "Not a valid Channel class #{channel_class_name}!") }
               response_agent_array << response_agent
-              response_agent.result = { response: { error: 'No such thing!' }}
             end
           rescue Exception => e
             response_agent = OpenStruct.new
+            response_agent.result = { notification: request['notification'].merge(error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}") }
             response_agent_array << response_agent
-            response_agent.result = { response: { error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}" }}
           end
         elsif request.key?('subscribe') && request['subscribe'].key?('agent_ids')
           begin
@@ -56,17 +72,23 @@ module Isomorfeus
             response_agent = Isomorfeus::Transport::ResponseAgent.new(agent_id, request['subscribe']['agent_ids'][agent_id])
             response_agent_array << response_agent
             channel = response_agent.request['channel']
-            class_name = response_agent.request['class']
-            if Isomorfeus.valid_channel_class_name?(class_name) && channel
-              channel_class = Isomorfeus.cached_channel_class(class_name)
-              if channel_class && Isomorfeus.current_user.authorized?(channel_class, :subscribe, channel)
-                Isomorfeus.pub_sub_client.subscribe(channel)
-                response_agent.agent_result = { success: channel }
+            channel_class_name = response_agent.request['class']
+            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
+              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
+              if channel_class && channel_class.valid_channel?(channel)
+                if Isomorfeus.current_user.authorized?(channel_class, :subscribe, channel)
+                  Isomorfeus.pub_sub_client.subscribe("#{channel_class_name}_#{channel}")
+                  response_agent.agent_result = { success: channel }
+                else
+                  response_agent.error = { error: "Not authorized!"}
+                end
               else
-                response_agent.error = { error: "Not authorized!"}
+                response_agent = OpenStruct.new
+                response_agent.result = { response: { error: "Not a valid channel #{channel} for #{channel_class_name}!" }}
+                response_agent_array << response_agent
               end
             else
-              response_agent.error = { error: "No such thing!"}
+              response_agent.error = { error: "Not a valid Channel class #{channel_class_name}!" }
             end
           rescue Exception => e
             response_agent.error = { error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}" }
@@ -77,17 +99,23 @@ module Isomorfeus
             response_agent = Isomorfeus::Transport::ResponseAgent.new(agent_id, request['unsubscribe']['agent_ids'][agent_id])
             response_agent_array << response_agent
             channel = response_agent.request['channel']
-            class_name = response_agent.request['class']
-            if Isomorfeus.valid_channel_class_name?(class_name) && channel
-              channel_class = Isomorfeus.cached_channel_class(class_name)
-              if channel_class && Isomorfeus.current_user.authorized?(channel_class, :unsubscribe, channel)
-                Isomorfeus.pub_sub_client.unsubscribe(channel)
-                response_agent.agent_result = { success: channel }
+            channel_class_name = response_agent.request['class']
+            if Isomorfeus.valid_channel_class_name?(channel_class_name) && channel
+              channel_class = Isomorfeus.cached_channel_class(channel_class_name)
+              if channel_class && channel_class.valid_channel?(channel)
+                if Isomorfeus.current_user.authorized?(channel_class, :unsubscribe, channel)
+                  Isomorfeus.pub_sub_client.unsubscribe("#{channel_class_name}_#{channel}")
+                  response_agent.agent_result = { success: channel }
+                else
+                  response_agent.error = { error: "Not authorized!"}
+                end
               else
-                response_agent.error = { error: "Not authorized!"}
+                response_agent = OpenStruct.new
+                response_agent.result = { response: { error: "Not a valid channel #{channel} for #{channel_class_name}!" }}
+                response_agent_array << response_agent
               end
             else
-              response_agent.error = { error: 'No such thing!'}
+              response_agent.error = { error: "Not a valid Channel class #{channel_class_name}!" }
             end
           rescue Exception => e
             response_agent.error = { error: "Isomorfeus::Transport::ServerProcessor: #{e.message}\n#{e.backtrace.join("\n")}" }

data/lib/isomorfeus/transport/server_socket_processor.rb

@@ -25,7 +25,7 @@ module Isomorfeus
         response_agent_array.each do |response_agent|
           result.deep_merge!(response_agent.result)
         end
-        client.write Oj.dump(result, mode: :strict)
+        client.write Oj.dump(result, mode: :strict) unless result.empty?
       ensure
         Thread.current[:isomorfeus_user] = nil
         Thread.current[:isomorfeus_pub_sub_client] = nil

data/lib/isomorfeus/transport/version.rb

@@ -1,5 +1,5 @@
 module Isomorfeus
   module Transport
-    VERSION = '1.0.0.zeta23'
+    VERSION = '1.0.0.zeta24'
   end
 end

data/lib/lucid_authentication/mixin.rb

@@ -16,7 +16,7 @@ module LucidAuthentication
 
           def promise_authentication_with_isomorfeus(user: nil, pass: nil, &block)
             if Isomorfeus.production?
-              Isomorfeus.raise_error(message: "Connection not secure, can't login") unless Isomorfeus::Transport.socket.url.start_with?('wss:')
+              Isomorfeus.raise_error(message: "Connection not secure, can't login!") unless Isomorfeus::Transport.socket.url.start_with?('wss:')
             else
               `console.warn("Connection not secure, ensure a secure connection in production, otherwise login will fail!")` unless Isomorfeus::Transport.socket.url.start_with?('wss:')
             end
@@ -47,9 +47,7 @@ module LucidAuthentication
                   `window.location = cookie_query` # doing page load and redirect
                   nil
                 else
-                  error = agent.response[:error]
-                  `console.err(error)` if error
-                  Isomorfeus.raise_error(message: 'Login failed!') # triggers .fail
+                  Isomorfeus.raise_error(message: "Login failed with '#{agent.response[:error]}'!") # triggers .fail
                 end
               end
             end

data/lib/lucid_channel/base.rb

@@ -1,11 +1,9 @@
 module LucidChannel
   class Base
-    if RUBY_ENGINE != 'opal'
-      def self.inherited(base)
-        Isomorfeus.add_valid_channel_class(base)
-      end
+    def self.inherited(base)
+      Isomorfeus.add_valid_channel_class(base)
     end
 
     include LucidChannel::Mixin
   end
-end
+end

data/lib/lucid_channel/mixin.rb

@@ -1,48 +1,103 @@
 module LucidChannel
   module Mixin
     def self.included(base)
-
-      if RUBY_ENGINE != 'opal'
-        Isomorfeus.add_valid_channel_class(base) unless base == LucidChannel::Base
-      end
+      Isomorfeus.add_valid_channel_class(base) unless base == LucidChannel::Base
 
       base.instance_exec do
-        def process_message(channel, message = nil)
-          if @message_processor
-            if channel == self.name
-              @message_processor.call(message)
-            else
-              @message_processor.call(channel, message)
-            end
-          else
-            puts "#{self} received: #{channel} #{message}, but no 'on_message' block defined!"
+        def subscription_channels
+          @subscription_channels ||= {}
+        end
+
+        def channel(name, options = {})
+          subscription_channels[name.to_s] = options
+        end
+
+        def valid_channel?(name)
+          name = name.to_s
+          subscription_channels.key?(name) || name == self.name
+        end
+
+        def process_message(message, error, channel = nil)
+          channel = self.name unless channel
+          channel = channel.to_s
+          unless valid_channel?(channel)
+            Isomorfeus.raise_error(message: "No such channel '#{channel}' declared for #{self.name}! Cannot process message")
           end
+          block = subscription_channels[channel][:block]
+          Isomorfeus.raise_error(message: "#{self} received: #{channel} #{message}, but no 'on_message' block defined!") unless block
+          block.call(message, error)
+          nil
         end
 
-        def on_message(&block)
-          @message_processor = block
+        def on_message(channel = nil, &block)
+          channel = self.name unless channel
+          channel = channel.to_s
+          unless valid_channel?(channel)
+            Isomorfeus.raise_error(message: "No such channel #{channel} declared, please declare it first!")
+          end
+          subscription_channels[channel] = {} unless subscription_channels.key?(channel)
+          subscription_channels[channel][:block] = block
         end
 
-        def send_message(channel, message = nil)
-          unless message
-            message = channel
-            channel = self.name
+        def send_message(message, channel = nil)
+          channel = self.name unless channel
+          unless valid_channel?(channel)
+            Isomorfeus.raise_error(message: "No such channel '#{channel}' declared for #{self.name}! Cannot send message")
           end
-          Isomorfeus::Transport.send_notification(self, channel, message)
+          Isomorfeus::Transport.send_message(self, channel, message)
         end
 
         def subscribe(channel = nil)
+          promise_subscribe(channel)
+          nil
+        end
+
+        def promise_subscribe(channel = nil)
           channel = channel ? channel : self.name
-          Isomorfeus::Transport.subscribe(self, channel)
+          Isomorfeus::Transport.promise_subscribe(self.name, channel)
         end
 
         def unsubscribe(channel = nil)
+          promise_unsubscribe(channel)
+          nil
+        end
+
+        def promise_unsubscribe(channel = nil)
           channel = channel ? channel : self.name
-          Isomorfeus::Transport.unsubscribe(self, channel)
+          Isomorfeus::Transport.promise_unsubscribe(self.name, channel)
         end
 
-        def current_user
-          Isomorfeus.current_user
+        if RUBY_ENGINE == 'opal'
+          def server_subscription_channels; end
+          def server_process_message(message, channel = nil); end
+          def server_on_message(channel = nil, &block); end
+        else
+          def server_is_processing_messages?(channel)
+            return false if server_subscription_channels.empty?
+            return true if server_subscription_channels.key?(channel) && server_subscription_channels[channel].key?(:block)
+            false
+          end
+
+          def server_subscription_channels
+            @server_subscription_channels ||= {}
+          end
+
+          def server_process_message(message, channel = nil)
+            channel = self.name unless channel
+            channel = channel.to_s
+            block = server_subscription_channels[channel][:block]
+            block.call(message)
+          end
+
+          def server_on_message(channel = nil, &block)
+            channel = self.name unless channel
+            channel = channel.to_s
+            unless valid_channel?(channel)
+              Isomorfeus.raise_error(message: "No such channel #{channel} declared, please declare it first!")
+            end
+            server_subscription_channels[channel] = {} unless server_subscription_channels.key?(channel)
+            server_subscription_channels[channel][:block] = block
+          end
         end
       end
     end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: isomorfeus-transport
 version: !ruby/object:Gem::Version
-  version: 1.0.0.zeta23
+  version: 1.0.0.zeta24
 platform: ruby
 authors:
 - Jan Biedermann
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-02-22 00:00:00.000000000 Z
+date: 2020-02-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -100,42 +100,42 @@ dependencies:
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.21
+        version: 4.0.22
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: 4.0.21
+        version: 4.0.22
 - !ruby/object:Gem::Dependency
   name: isomorfeus-react
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 16.12.23
+        version: 16.13.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 16.12.23
+        version: 16.13.0
 - !ruby/object:Gem::Dependency
   name: isomorfeus-policy
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.zeta23
+        version: 1.0.0.zeta24
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.zeta23
+        version: 1.0.0.zeta24
 - !ruby/object:Gem::Dependency
   name: websocket-driver
   requirement: !ruby/object:Gem::Requirement
@@ -156,14 +156,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.zeta23
+        version: 1.0.0.zeta24
   type: :development
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 1.0.0.zeta23
+        version: 1.0.0.zeta24
 - !ruby/object:Gem::Dependency
   name: opal-webpack-loader
   requirement: !ruby/object:Gem::Requirement