hyper-operation 1.0.alpha1.2 → 1.0.alpha1.7

data/lib/hyper-operation/server_op.rb

@@ -13,14 +13,18 @@ module Hyperstack
             hash = serialize_params(hash)
             Hyperstack::HTTP.post(
               "#{`window.HyperstackEnginePath`}/execute_remote",
-              payload: {json: {operation: name, params: hash}.to_json},
-              headers: {'X-CSRF-Token' => Hyperstack::ClientDrivers.opts[:form_authenticity_token] }
+              payload: {hyperstack_secured_json: {operation: name, params: hash}.to_json},
+              headers: headers.merge('X-CSRF-Token' => Hyperstack::ClientDrivers.opts[:form_authenticity_token])
               )
             .then do |response|
               deserialize_response response.json[:response]
             end
             .fail do |response|
-              Exception.new response.json[:error]
+              begin
+                const_get(response.json[:error_class]).new(response.json[:error])
+              rescue
+                Exception.new response.json[:error]
+              end
             end
           end
         elsif on_opal_server?
@@ -74,7 +78,7 @@ module Hyperstack
           if _Railway.params_wrapper.method_defined?(:controller)
             params[:controller] = controller
           elsif !_Railway.params_wrapper.method_defined?(security_param)
-            raise AccessViolation
+            raise AccessViolation.new(:remote_access_not_allowed)
           end
           run(deserialize_params(params))
           .then { |r| return { json: { response: serialize_response(r) } } }
@@ -84,13 +88,27 @@ module Hyperstack
         handle_exception(e, operation, params)
       end
 
+      def status(e)
+        if e.is_a? AccessViolation
+          403
+        elsif e.is_a? Operation::ValidationException
+          400
+        else
+          500
+        end
+      end
+
       def handle_exception(e, operation, params)
-        if defined? ::Rails
-          params.delete(:controller)
-          ::Rails.logger.debug "\033[0;31;1mERROR: Hyperstack::ServerOp exception caught when running "\
-                               "#{operation} with params \"#{params}\": #{e}\033[0;30;21m"
+        if e.respond_to? :__hyperstack_on_error
+          params = params.to_h
+          message = []
+          message << Pastel.new.red("HYPERSTACK ERROR during #{operation} #{e.inspect}")
+          params.each { |param, value| message << "  #{param} => #{value.inspect.truncate(120, separator: '...')}" }
+          message << "\n#{e.details}" if e.respond_to? :details
+          e.__hyperstack_on_error(operation, params, message.join("\n"))
         end
-        { json: { error: e }, status: 500 }
+
+        { json: { error_class: e.class.to_s, error: e}, status: status(e) }
       end
 
 
@@ -111,6 +129,10 @@ module Hyperstack
         promise.reject e
       end
 
+      def headers
+        {}
+      end
+
       def serialize_params(hash)
         hash
       end

data/lib/hyper-operation/transport/client_drivers.rb

@@ -6,6 +6,10 @@ module Hyperstack
   # We use ERB to determine the configuration and implement the appropriate
   # client interface to sync_change or sync_destroy
 
+  def self.anti_csrf_token
+    ClientDrivers.opts[:form_authenticity_token]
+  end
+
   class Application
     extend Component::IsomorphicHelpers::ClassMethods
 
@@ -31,16 +35,35 @@ module Hyperstack
 
 
   if RUBY_ENGINE == 'opal'
+    # Patch in a dummy copy of Model.load in case we are not using models
+    # this will be defined properly by hyper-model
+    module Model
+      def self.load
+        Promise.new.tap { |promise| promise.resolve(yield) }
+      end unless respond_to?(:load)
+    end
+
     def self.connect(*channels)
       channels.each do |channel|
         if channel.is_a? Class
           IncomingBroadcast.connect_to(channel.name)
         elsif channel.is_a?(String) || channel.is_a?(Array)
           IncomingBroadcast.connect_to(*channel)
-        elsif channel.id
-          IncomingBroadcast.connect_to(channel.class.name, channel.id)
+        elsif channel.respond_to?(:id)
+          Hyperstack::Model.load do
+            channel.id
+          end.then do |id|
+            raise "Hyperstack.connect cannot connect to #{channel.inspect}.  "\
+                  "The id is nil. This can be caused by connecting to a model "\
+                  "that is not saved, or that does not exist." unless id
+            IncomingBroadcast.connect_to(channel.class.name, id)
+          end
         else
-          raise "cannot connect to model before it has been saved"
+          raise "Hyperstack.connect cannot connect to #{channel.inspect}.\n"\
+                "Channels must be either a class, or a class name,\n"\
+                "a string in the form 'ClassName-id',\n"\
+                "an array in the form [class, id] or [class-name, id],\n"\
+                "or an object that responds to the id method with a non-nil value"
         end
       end
     end
@@ -61,19 +84,22 @@ module Hyperstack
 
       def self.add_connection(channel_name, id = nil)
         channel_string = "#{channel_name}#{'-'+id.to_s if id}"
+        return if open_channels.include? channel_string
         open_channels << channel_string
         channel_string
       end
 
       def self.connect_to(channel_name, id = nil)
         channel_string = add_connection(channel_name, id)
+        return unless channel_string # already connected!
         if ClientDrivers.opts[:transport] == :pusher
           channel = "#{ClientDrivers.opts[:channel]}-#{channel_string}"
           %x{
             var channel = #{ClientDrivers.opts[:pusher_api]}.subscribe(#{channel.gsub('::', '==')});
             channel.bind('dispatch', #{ClientDrivers.opts[:dispatch]})
-            channel.bind('pusher:subscription_succeeded', #{lambda {ClientDrivers.get_queued_data("connect-to-transport", channel_string)}})
+            channel.bind('pusher:subscription_succeeded', #{->(*) { ClientDrivers.get_queued_data("connect-to-transport", channel_string)}})
           }
+          @pusher_dispatcher_registered = true
         elsif ClientDrivers.opts[:transport] == :action_cable
           channel = "#{ClientDrivers.opts[:channel]}-#{channel_string}"
           Hyperstack::HTTP.post(ClientDrivers.polling_path('action-cable-auth', channel), headers: { 'X-CSRF-Token' => ClientDrivers.opts[:form_authenticity_token] }).then do |response|
@@ -143,7 +169,7 @@ module Hyperstack
       config_hash = {
         transport: Hyperstack.transport,
         id: id,
-        acting_user_id: (controller.acting_user && controller.acting_user.id),
+        acting_user_id: (controller.acting_user.respond_to?(:id) && controller.acting_user.id),
         env: ::Rails.env,
         client_logging: Hyperstack.client_logging,
         pusher_fake_js: pusher_fake_js,
@@ -159,12 +185,17 @@ module Hyperstack
         # not sure why the second check is needed.  It happens in the test app
         route.app == Hyperstack::Engine or (route.app.respond_to?(:app) and route.app.app == Hyperstack::Engine)
       end
-      raise 'Hyperstack::Engine mount point not found.  Check your config/routes.rb file' unless path
-      path = path.path.spec
-      "<script type='text/javascript'>\n"\
-        "window.HyperstackEnginePath = '#{path}';\n"\
-        "window.HyperstackOpts = #{config_hash.to_json}\n"\
-      "</script>\n"
+      if path
+        path = path.path.spec
+        "<script type='text/javascript'>\n"\
+          "window.HyperstackEnginePath = '#{path}';\n"\
+          "window.HyperstackOpts = #{config_hash.to_json}\n"\
+        "</script>\n"
+      else
+        "<script type='text/javascript'>\n"\
+          "window.HyperstackOpts = #{config_hash.to_json}\n"\
+        "</script>\n"
+      end
     end if RUBY_ENGINE != 'opal'
 
     class << self
@@ -218,6 +249,9 @@ module Hyperstack
 
         @opts = Hash.new(`window.HyperstackOpts`)
 
+        if opts[:transport] != :none && `typeof(window.HyperstackEnginePath) == 'undefined'`
+          raise "No hyperstack mount point found!\nCheck your Rails routes.rb file";
+        end
 
         if opts[:transport] == :pusher
 

data/lib/hyper-operation/transport/connection.rb

@@ -1,173 +1,95 @@
-module Hyperstack
-  module AutoCreate
-    def table_exists?
-      # works with both rails 4 and 5 without deprecation warnings
-      if connection.respond_to?(:data_sources)
-        connection.data_sources.include?(table_name)
-      else
-        connection.tables.include?(table_name)
-      end
-    end
-
-    def needs_init?
-      Hyperstack.transport != :none && Hyperstack.on_server? && !table_exists?
-    end
-
-    def create_table(*args, &block)
-      connection.create_table(table_name, *args, &block) if needs_init?
-    end
-  end
-
-  class Connection < ActiveRecord::Base
-    class QueuedMessage < ActiveRecord::Base
-
-      extend AutoCreate
-
-      self.table_name = 'hyperstack_queued_messages'
-
-      do_not_synchronize
-
-      serialize :data
+# frozen_string_literal: true
 
-      belongs_to :hyperstack_connection,
-                 class_name: 'Hyperstack::Connection',
-                 foreign_key: 'connection_id'
-
-      scope :for_session,
-            ->(session) { joins(:hyperstack_connection).where('session = ?', session) }
-
-      # For simplicity we use QueuedMessage with connection_id 0
-      # to store the current path which is used by consoles to
-      # communicate back to the server
-
-      default_scope { where('connection_id IS NULL OR connection_id != 0') }
+module Hyperstack
+  class Connection
+    class << self
+      attr_accessor :transport, :connection_adapter, :show_diagnostics
+
+      def adapter
+        adapter_name = Hyperstack.connection[:adapter].to_s
+        adapter_path = "hyper-operation/transport/connection_adapter/#{adapter_name}"
+
+        begin
+          require adapter_path
+        rescue LoadError => e
+          if e.path == adapter_path
+            raise e.class, "Could not load the '#{adapter_name}' adapter. Make sure the adapter is spelled correctly in your Hyperstack config, and the necessary gems are in your Gemfile.", e.backtrace
+
+          # Bubbled up from the adapter require. Prefix the exception message
+          # with some guidance about how to address it and reraise.
+          else
+            raise e.class, "Error loading the '#{adapter_name}' adapter. Missing a gem it depends on? #{e.message}", e.backtrace
+          end
+        end
 
-      def self.root_path=(path)
-        unscoped.find_or_create_by(connection_id: 0).update(data: path)
+        adapter_name = adapter_name.camelize
+        "Hyperstack::ConnectionAdapter::#{adapter_name}".constantize
       end
 
-      def self.root_path
-        unscoped.find_or_create_by(connection_id: 0).data
+      def build_tables
+        adapter.build_tables
       end
-    end
-
-    extend AutoCreate
 
-    def self.build_tables
-      create_table(force: :cascade) do |t|
-        t.string   :channel
-        t.string   :session
-        t.datetime :created_at
-        t.datetime :expires_at
-        t.datetime :refresh_at
-      end
-      QueuedMessage.create_table(force: :cascade) do |t|
-        t.text    :data
-        t.integer :connection_id
+      def build_tables?
+        adapter.respond_to?(:build_tables)
       end
-    end
-
-    do_not_synchronize
-
-    self.table_name = 'hyperstack_connections'
-
-    has_many :messages,
-             foreign_key: 'connection_id',
-             class_name: 'Hyperstack::Connection::QueuedMessage',
-             dependent: :destroy
-    scope :expired,
-          -> { where('expires_at IS NOT NULL AND expires_at < ?', Time.zone.now) }
-    scope :pending_for,
-          ->(channel) { where(channel: channel).where('session IS NOT NULL') }
-    scope :inactive,
-          -> { where('session IS NULL AND refresh_at < ?', Time.zone.now) }
-
-    def self.needs_refresh?
-      exists?(['refresh_at IS NOT NULL AND refresh_at < ?', Time.zone.now])
-    end
-
-    def transport
-      self.class.transport
-    end
-
-    before_create do
-      if session
-        self.expires_at = Time.now + transport.expire_new_connection_in
-      elsif transport.refresh_channels_every != :never
-        self.refresh_at = Time.now + transport.refresh_channels_every
-      end
-    end
-
-    class << self
-      attr_accessor :transport
 
       def active
-        # if table doesn't exist then we are either calling from within
-        # a migration or from a console before the server has ever started
-        # in these cases there are no channels so we return nothing
-        return [] unless table_exists?
-        if Hyperstack.on_server?
-          expired.delete_all
-          refresh_connections if needs_refresh?
-        end
-        all.pluck(:channel).uniq
+        adapter.active
       end
 
       def open(channel, session = nil, root_path = nil)
-        self.root_path = root_path
-        find_or_create_by(channel: channel, session: session)
+        puts "open(#{channel}, #{session}, #{root_path})" if show_diagnostics
+
+        adapter.open(channel, session, root_path).tap do |c|
+          puts " - open returning #{c}" if show_diagnostics
+        end
       end
 
       def send_to_channel(channel, data)
-        pending_for(channel).each do |connection|
-          QueuedMessage.create(data: data, hyperstack_connection: connection)
-        end
-        transport.send_data(channel, data) if exists?(channel: channel, session: nil)
+        puts "send_to_channel(#{channel}, #{data})" if show_diagnostics
+
+        adapter.send_to_channel(channel, data)
       end
 
       def read(session, root_path)
-        self.root_path = root_path
-        where(session: session)
-          .update_all(expires_at: Time.now + transport.expire_polled_connection_in)
-        QueuedMessage.for_session(session).destroy_all.pluck(:data)
+        puts "read(#{session}, #{root_path})" if show_diagnostics
+
+        adapter.read(session, root_path)
       end
 
       def connect_to_transport(channel, session, root_path)
-        self.root_path = root_path
-        if (connection = find_by(channel: channel, session: session))
-          messages = connection.messages.pluck(:data)
-          connection.destroy
-        else
-          messages = []
-        end
-        open(channel)
-        messages
+        puts "connect_to_transport(#{channel}, #{session}, #{root_path})" if show_diagnostics
+
+        adapter.connect_to_transport(channel, session, root_path)
       end
 
       def disconnect(channel)
-        find_by(channel: channel, session: nil).destroy
+        adapter.disconnect(channel)
       end
 
       def root_path=(path)
-        QueuedMessage.root_path = path if path
+        adapter.root_path = path
       end
 
       def root_path
-        # if the QueuedMessage table doesn't exist then we are either calling from within
-        # a migration or from a console before the server has ever started
-        # in these cases there is no root path to the server
-        QueuedMessage.root_path if QueuedMessage.table_exists?
+        adapter.root_path
       end
 
       def refresh_connections
-        refresh_started_at = Time.zone.now
-        channels = transport.refresh_channels
-        next_refresh = refresh_started_at + transport.refresh_channels_every
-        channels.each do |channel|
-          connection = find_by(channel: channel, session: nil)
-          connection.update(refresh_at: next_refresh) if connection
+        adapter.refresh_connections
+      end
+
+      def method_missing(method_name, *args, &block)
+        if adapter::Connection.respond_to?(method_name)
+          adapter::Connection.send(method_name, *args, &block)
+        else
+          super
         end
-        inactive.delete_all
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        adapter::Connection.respond_to?(method_name)
       end
     end
   end

data/lib/hyper-operation/transport/connection_adapter/active_record.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require_relative 'active_record/connection'
+require_relative 'active_record/queued_message'
+
+module Hyperstack
+  module ConnectionAdapter
+    module ActiveRecord
+      class << self
+        def build_tables
+          Connection.create_table(force: :cascade) do |t|
+            t.string   :channel
+            t.string   :session
+            t.datetime :created_at
+            t.datetime :expires_at
+            t.datetime :refresh_at
+          end
+
+          QueuedMessage.create_table(force: :cascade) do |t|
+            t.text    :data
+            t.integer :connection_id
+          end
+        end
+
+        def transport
+          Hyperstack::Connection.transport
+        end
+
+        def active
+          # if table doesn't exist then we are either calling from within
+          # a migration or from a console before the server has ever started
+          # in these cases there are no channels so we return nothing
+          return [] unless Connection.table_exists?
+
+          if Hyperstack.on_server?
+            Connection.expired.delete_all
+            refresh_connections if Connection.needs_refresh?
+          end
+
+          Connection.all.pluck(:channel).uniq
+        rescue ::ActiveRecord::StatementInvalid
+          []
+        end
+
+        def open(channel, session = nil, root_path = nil)
+          self.root_path = root_path
+
+          Connection.find_or_create_by(channel: channel, session: session)
+        end
+
+        def send_to_channel(channel, data)
+          Connection.pending_for(channel).each do |connection|
+            QueuedMessage.create(data: data, hyperstack_connection: connection)
+          end
+
+          transport.send_data(channel, data) if Connection.exists?(channel: channel, session: nil)
+        end
+
+        def read(session, root_path)
+          self.root_path = root_path
+
+          Connection.where(session: session)
+                    .update_all(expires_at: Time.current + transport.expire_polled_connection_in)
+
+          QueuedMessage.for_session(session).destroy_all.pluck(:data)
+        end
+
+        def connect_to_transport(channel, session, root_path)
+          self.root_path = root_path
+
+          if (connection = Connection.find_by(channel: channel, session: session))
+            messages = connection.messages.pluck(:data)
+            connection.destroy
+          else
+            messages = []
+          end
+
+          open(channel)
+
+          messages
+        end
+
+        def disconnect(channel)
+          Connection.find_by(channel: channel, session: nil).destroy
+        end
+
+        def root_path=(path)
+          QueuedMessage.root_path = path if path
+        end
+
+        def root_path
+          # if the QueuedMessage table doesn't exist then we are either calling from within
+          # a migration or from a console before the server has ever started
+          # in these cases there is no root path to the server
+          QueuedMessage.root_path if QueuedMessage.table_exists?
+        end
+
+        def refresh_connections
+          refresh_started_at = Time.current
+          channels = transport.refresh_channels
+          next_refresh = refresh_started_at + transport.refresh_channels_every
+
+          channels.each do |channel|
+            connection = Connection.find_by(channel: channel, session: nil)
+            connection.update(refresh_at: next_refresh) if connection
+          end
+
+          Connection.inactive.delete_all
+        end
+      end
+    end
+  end
+end