loco-rails 4.0.0 → 6.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14ddadb549243851cfae8f6260dbe08b6813392116f03b83d4618615598ec2d3
-  data.tar.gz: c5cdfc9d981ce63a5e8237cb794d7eb2a9d8435941070bba84f65f188e08e215
+  metadata.gz: 479391be7cf538ec1e33167e15508617bbd6312f607204185f0be6f12bba0372
+  data.tar.gz: 1365a880d79a4e838a6101de9bd5ec7678f4f2be74bd3be9570f898d3949ccf0
 SHA512:
-  metadata.gz: '0921bb8ffff692bede6999ae0dc2de20d1822c0ca3b5a8bac0aabcd50909a12369a6987da6b309356e4306dfd3891aea85adff8c418cce1eacabc4bd73348509'
-  data.tar.gz: f8d9d259ae99c421bcbdbf03df5fa1878ae6dd590eb835d6c432a6c6e91b103df5d5efbcdfe9daff6ae1d4fbb2bab1c193d3416b1e6213b7e134842d7f2dea48
+  metadata.gz: e7d596e1289162d46b33bb68355032e64c125ed80e82a2be7203ccb6dd5095bdf511a82f71be2346188e45d7232c654c84b0d0234fc260f3e15ea2c211a0627a
+  data.tar.gz: 7a3dd738a162abd503389b5e46173f3d68bd3de72c672a1df5ea94eb7cc3e168d40a07f809841d50de5f70111265fd730a6db28c3a1e1800bd167956963d8bd5

data/app/channels/loco/notification_center_channel.rb

@@ -5,61 +5,37 @@ module Loco
     def subscribed
       return unless loco_permissions.is_a?(Array)
 
-      stream_for_resources
-      return if loco_permissions.compact.size > 1
+      @uuid, *signed_in_resources = PermissionsPresenter.signed_in(loco_permissions)
+      return unless @uuid.is_a?(String)
 
-      SenderJob.perform_later @uuid, loco: { start_ajax_polling: true }
+      stream_from("loco:notification_center:#{@uuid}")
+      broadcast_to(@uuid, loco: { uuid: @uuid })
+      signed_in_resources.each { |resource| WsConnectionManager.new(resource).add(@uuid) }
     end
 
     def unsubscribed
-      loco_permissions.each do |resource|
-        next if resource.nil? || resource.is_a?(String)
-
-        UuidJob.perform_later serialize_resource(resource), @uuid, 'del'
+      PermissionsPresenter.signed_in(loco_permissions, except: :uuid).each do |resource|
+        WsConnectionManager.new(resource).del(@uuid)
       end
     end
 
-    def receive(data)
-      update_connections if data['loco'] && data['loco']['connection_check']
-      NotificationCenter.new.received_message permissions, data
-    end
-
-    protected
-
-    def stream_for_resources
-      loco_permissions.compact.each do |resource|
-        if resource.is_a? String
-          @uuid = resource
-          stream_for_resource resource
-          SenderJob.perform_later @uuid, loco: { uuid: @uuid }
-        else
-          UuidJob.perform_later serialize_resource(resource), @uuid, 'add'
-          stream_for_resource resource
-        end
+    def receive(payload)
+      if payload.dig('loco', 'pong')
+        update_connections
+        broadcast_to(@uuid, loco: { ping: true })
       end
-    end
+      return if payload.keys == ['loco']
 
-    def stream_for_resource(resource)
-      identifier = WsConnectionManager.new(resource).identifier
-      stream_from "loco:notification_center:#{identifier}"
+      indexed_permissions = PermissionsPresenter.indexed(loco_permissions)
+      NotificationCenter.new.received_message(indexed_permissions, payload)
     end
 
-    def permissions
-      loco_permissions.compact.index_by do |o|
-        o.class.name.downcase.to_sym
-      end
-    end
+    protected
 
     def update_connections
-      permissions.each do |key, val|
-        next if key == :string
-
-        UuidJob.perform_later serialize_resource(val), @uuid, 'update'
+      PermissionsPresenter.indexed(loco_permissions, except: :uuid).each do |_, resource|
+        WsConnectionManager.new(resource).update(@uuid)
       end
     end
-
-    def serialize_resource(resource)
-      { 'class' => resource.class.name, 'id' => resource.id }
-    end
   end
 end

data/app/controllers/loco/notification_center_controller.rb

@@ -21,41 +21,16 @@ module Loco
         render json: [[], Time.current.iso8601(6)]
         return
       end
-      fetcher = Notification::Fetcher.new notif_fetcher_args
-      render json: [
-        fetcher.formatted_notifications,
-        fetcher.next_sync_time.iso8601(6)
-      ]
-    end
-
-    def notif_fetcher_args
-      {
-        synced_at: params[:synced_at],
-        permissions: permissions,
-        recipient_token: params[:token]
-      }
+      fetcher = Notification::Fetcher.new({ synced_at: params[:synced_at],
+                                            permissions: permissions,
+                                            recipient_token: params[:token] })
+      render json: [fetcher.formatted_notifications, fetcher.next_sync_time.iso8601(6)]
     end
 
     def permissions
-      return [] unless defined? loco_permissions
-      return loco_permissions if params[:uuid].blank?
-
-      process_loco_permissions
-    end
+      return [] unless defined?(loco_permissions)
 
-    def process_loco_permissions
-      resources_to_del = []
-      resources_to_add = []
-      loco_permissions.each do |resource|
-        next if resource.nil?
-
-        ws_conn_manager = WsConnectionManager.new resource
-        next unless ws_conn_manager.connected?(params[:uuid])
-
-        resources_to_del << resource
-        resources_to_add << resource.class
-      end
-      loco_permissions - resources_to_del + resources_to_add.uniq
+      loco_permissions
     end
   end
 end

data/app/jobs/loco/sender_job.rb

@@ -5,7 +5,7 @@ module Loco
     queue_as :loco
 
     def perform(recipient, data)
-      Sender.new(recipient, data).emit
+      Sender.(recipient, data)
     end
   end
 end

data/app/models/loco/notification.rb

@@ -2,6 +2,9 @@
 
 module Loco
   class Notification < ApplicationRecord
+    FOR_OBJ_SQL_TMPL = 'recipient_class = ? AND recipient_id = ?'
+    FOR_CLASS_SQL_TMPL = 'recipient_class = ? AND recipient_id IS NULL'
+
     attr_reader :obj
 
     serialize :data, JSON
@@ -31,9 +34,9 @@ module Loco
       return if val.nil?
       return if val == :all
 
-      if val.is_a? String
+      if val.is_a?(String)
         self.recipient_token = val
-      elsif val.instance_of? Class
+      elsif val.instance_of?(Class)
         self.recipient_class = val.to_s
       else
         self.recipient_class = val.class.name
@@ -41,17 +44,14 @@ module Loco
       end
     end
 
-    def recipient(opts = {})
-      return recipient_token if recipient_token
-      return unless regular_recipient?
-      return class_recipient unless recipient_id
-
-      obj_recipient opts[:shallow]
-    end
-
-    def prepare
-      set_event
-      set_data
+    def recipient(shallow: false)
+      if !recipient_token.nil?
+        recipient_token
+      elsif regular_recipient?
+        init_recipient(shallow)
+      elsif !recipient_class.nil?
+        recipient_class.constantize
+      end
     end
 
     def compact
@@ -61,41 +61,42 @@ module Loco
     private
 
     def regular_recipient?
-      recipient_class && recipient_id
+      !recipient_class.nil? && !recipient_id.nil?
     end
 
-    def class_recipient
-      recipient_class.constantize
-    end
-
-    def obj_recipient(shallow = false)
+    def init_recipient(shallow)
       if shallow
-        recipient_class.constantize.new id: recipient_id
+        recipient_class.constantize.new(id: recipient_id)
       else
-        recipient_class.constantize.find recipient_id
+        recipient_class.constantize.find(recipient_id)
       end
     end
 
+    def prepare
+      set_event
+      set_data
+    end
+
     def set_event
       return if event.present?
-      return if obj.instance_of? Class
+      return if obj.instance_of?(Class)
 
-      if obj.new_record?
-        self.event = 'creating'
-      else
-        set_event_for_persisted_obj
-      end
+      self.event = if obj.new_record?
+                     'creating'
+                   else
+                     event_for_persisted_obj
+                   end
     end
 
-    def set_event_for_persisted_obj
-      self.event = obj.created_at == obj.updated_at ? 'created' : 'updated'
+    def event_for_persisted_obj
+      obj.created_at == obj.updated_at ? 'created' : 'updated'
     end
 
     def set_data
       self.data ||= {}
       return if obj.nil?
 
-      self.data.merge!(id: obj.id)
+      self.data = data.merge(id: obj.id)
     end
   end
 end

data/app/services/loco/notification/fetcher.rb

@@ -5,17 +5,12 @@ module Loco
     class Fetcher
       attr_accessor :max_size
 
-      def initialize(
-        synced_at:,
-        permissions: [],
-        recipient_token: nil,
-        max_size: nil
-      )
-        @synced_at = synced_at
-        @permissions = permissions
-        @recipient_token = recipient_token
+      def initialize(opts)
+        @synced_at = opts[:synced_at]
+        @permissions = (opts[:permissions] || []).compact
+        @recipient_token = opts[:recipient_token]
         @notifications = nil
-        @max_size = max_size || Loco::Config.notifications_size
+        @max_size = opts[:max_size] || Loco::Config.notifications_size
       end
 
       def formatted_notifications
@@ -56,17 +51,11 @@ module Loco
           recipient_class: nil,
           recipient_id: nil,
           recipient_token: nil
-        ).first max_size
+        ).first(max_size)
       end
 
       def notifications_behind_permissions
-        notifications = []
-        @permissions.each do |resource|
-          next unless resource
-
-          notifications += notification_for_resource resource
-        end
-        notifications
+        @permissions.inject([]) { |arr, resource| arr + notification_for_resource(resource) }
       end
 
       def notifications_behind_token
@@ -74,15 +63,13 @@ module Loco
       end
 
       def notification_for_resource(resource)
-        if resource.instance_of? Class
-          sql = 'recipient_class = ? AND recipient_id IS NULL'
-          return default_scope.where(sql, resource.to_s).first max_size
+        if resource.instance_of?(Class)
+          return default_scope.where(Notification::FOR_CLASS_SQL_TMPL, resource.to_s)
+                              .first(max_size)
         end
         klass = resource.class.name
-        cond1 = '(recipient_class = ? AND recipient_id = ?)'
-        cond2 = '(recipient_class = ? AND recipient_id IS NULL)'
-        sql = "#{cond1} OR #{cond2}"
-        default_scope.where(sql, klass, resource.id, klass).first max_size
+        sql = "(#{Notification::FOR_OBJ_SQL_TMPL}) OR (#{Notification::FOR_CLASS_SQL_TMPL})"
+        default_scope.where(sql, klass, resource.id, klass).first(max_size)
       end
     end
   end

data/lib/generators/loco/file_injector/templates/connection.rb

@@ -1,6 +1,7 @@
     identified_by :loco_permissions
 
     def connect
+      reject_unauthorized_connection unless current_user || current_admin
       # loco_permissions should be the same as in application_controller.rb
       # + SecureRandom.uuid is mandatory at 1st position
       self.loco_permissions = [SecureRandom.uuid, current_user, current_admin]

data/lib/loco/broadcaster.rb

@@ -2,99 +2,51 @@
 
 module Loco
   class Broadcaster
-    attr_reader :obj, :event, :recipients, :data, :notifications
-
-    def initialize(obj, event = nil, opts = {})
-      recipient_key = opts[:for] ? :for : :to
-      @obj = obj
-      @event = event
-      @recipients = opts[recipient_key] ? [*opts[recipient_key]] : [nil]
-      @data = opts[:data]
-      @notifications = []
-      @sent_via_ws = 0
-      @conn_res_manager = WsConnectedResourcesManager.new @recipients.compact
-    end
-
-    def emit
-      init_notifications if notifications.empty?
-      send_notifications
-      if notify_about_xhr_notifications?
-        notify_about_xhr_notifications
-      else
-        set_sync_time_via_ws
+    class << self
+      def call(obj, event, recipients: nil, payload: nil)
+        payload ||= {}
+        payload[:loco] = { idempotency_key: SecureRandom.hex }
+        send_notifications(obj, event, process_recipients(recipients), payload)
       end
-    end
 
-    private
+      private
 
-    def init_notifications
-      recipients.each do |recipient|
-        @notifications << Notification.new(
-          obj: obj,
-          event: event,
-          recipient: recipient,
-          data: data
-        )
+      def process_recipients(recipients)
+        recipients = [:all] if recipients.nil?
+        recipients = [recipients] unless recipients.is_a?(Array)
+        recipients = recipients.map { |e| e.nil? ? :all : e }
+        recipients = [:all] if recipients.include?(:all)
+        recipients
       end
-    end
-
-    def send_notifications
-      notifications.each do |notification|
-        notification.save!
-        next if notification.recipient_id.nil?
 
-        shallow_recipient = notification.recipient shallow: true
-        next unless @conn_res_manager.connected? shallow_recipient
-
-        send_via_ws notification
-      end
-    end
-
-    def send_via_ws(notification)
-      recipient = notification.recipient shallow: true
-      data = { loco: { notification: notification.compact } }
-      SenderJob.perform_later recipient, data
-      @sent_via_ws += 1
-    end
-
-    def notify_about_xhr_notifications?
-      @sent_via_ws < notifications.size
-    end
-
-    def notify_about_xhr_notifications
-      uuids = []
-      fetch_identifiers.each do |ident|
-        Loco::WsConnectionManager.new(ident).connected_uuids.each do |uuid|
-          next if uuids.include? uuid
-
-          uuids << uuid
-          SenderJob.perform_later uuid, loco: { xhr_notifications: true }
+      def send_notifications(obj, event, recipients, payload)
+        recipients.each do |recipient|
+          notification = Notification.create!(
+            obj: obj,
+            event: event,
+            recipient: recipient,
+            data: payload
+          )
+          sync_time = notification.created_at.iso8601(6)
+          send_notification(keify_recipient(recipient), notification, sync_time)
         end
       end
-    end
-
-    def set_sync_time_via_ws
-      sync_time = notifications.last.created_at.iso8601(6)
-      notifications.each do |notification|
-        recipient = notification.recipient shallow: true
-        SenderJob.perform_later recipient, loco: { sync_time: sync_time }
-      end
-    end
 
-    def notifications_recipients
-      notifications.map { |n| n.recipient shallow: true }.map do |o|
-        o.instance_of?(Class) ? o.to_s.downcase : nil
+      def keify_recipient(recipient)
+        case recipient
+        when String then { 'token' => recipient }
+        when Class then { 'class' => recipient.name }
+        else recipient
+        end
       end
-    end
 
-    def fetch_identifiers
-      recipients = notifications_recipients
-      uniq_recipients = recipients.compact.uniq
-      Loco::WsConnectedResourcesManager.identifiers.find_all do |str|
-        if recipients.include? nil
-          true
+      def send_notification(recipient, notification, sync_time)
+        if notification.recipient_id
+          Sender.(recipient, loco: { notification: notification.compact })
+          Sender.(recipient, loco: { sync_time: sync_time })
         else
-          uniq_recipients.include? str.split(':').first
+          SenderJob.perform_later(recipient, loco: { notification: notification.compact })
+          SenderJob.perform_later(recipient, loco: { sync_time: sync_time })
         end
       end
     end

data/lib/loco/emitter.rb

@@ -3,23 +3,28 @@
 module Loco
   module Emitter
     def emit(obj, event = nil, opts = {})
-      Broadcaster.new(obj, event, opts).emit
+      Broadcaster.(
+        obj,
+        event,
+        payload: opts[:payload] || opts[:data],
+        recipients: opts[opts[:for] ? :for : :to]
+      )
     end
 
-    def emit_to(recipient, data)
-      Sender.new(recipient, data).emit
+    def emit_to(recipient_s, data)
+      Sender.(recipient_s, data)
     end
 
     def add_hub(name, members = [])
-      Hub.new(name, members).save
+      Hub.set(name, members)
     end
 
     def get_hub(name)
-      Hub.get name
+      Hub.get(name)
     end
 
     def del_hub(name)
-      hub = Hub.get name
+      hub = Hub.get(name)
       return false if hub.nil?
 
       hub.destroy

data/lib/loco/hub.rb

@@ -2,71 +2,64 @@
 
 module Loco
   class Hub
-    PREFIX = 'loco:hub:'
-
-    attr_reader :raw_members
-
-    def initialize(name, members = [])
-      @name = "#{PREFIX}#{name}"
-      @raw_members = members.map { |m| serialize m }
-    end
+    PREFIX = 'hub:'
 
     class << self
+      def set(name, members)
+        new(name, members)
+      end
+
       def get(name)
-        hub = WsConnectionStorage.current.get "#{PREFIX}#{name}"
-        return nil if hub.blank?
+        return nil if WsConnectionStorage.current.type("s:#{full_name(name)}") != 'set'
 
-        new name, JSON.parse(hub)
+        new(name)
       end
+
+      def full_name(val)
+        "#{PREFIX}#{val}"
+      end
+    end
+
+    def initialize(name, members = [])
+      @name = self.class.full_name(name)
+      members.map { |member| add_member(member) }
     end
 
     def name
-      @name.split(PREFIX).last
+      full_name.split(PREFIX).last
     end
 
-    def add_member(member)
-      serialized = serialize member
-      return raw_members if raw_members.include? serialized
+    def full_name
+      @name
+    end
 
-      raw_members << serialized
-      save
-      raw_members
+    def add_member(member)
+      WsConnectionStorage.current.add(@name, WsConnectionIdentifier.(member))
     end
 
     def del_member(member)
-      serialized = serialize member
-      return nil unless raw_members.include? serialized
-
-      raw_members.delete serialized
-      save
-      serialized
+      WsConnectionStorage.current.rem(@name, WsConnectionIdentifier.(member))
     end
 
     def destroy
-      WsConnectionStorage.current.del @name
-      true
+      WsConnectionStorage.current.members(@name).each do |member|
+        WsConnectionStorage.current.rem(@name, member)
+      end
     end
 
-    def save
-      WsConnectionStorage.current.set @name, raw_members.to_json
-      self
+    def include?(resource)
+      WsConnectionStorage.current.member?(@name, WsConnectionIdentifier.(resource))
     end
 
-    def include?(resource)
-      raw_members.include? serialize(resource)
+    def raw_members
+      WsConnectionStorage.current.members(@name)
     end
 
     def members
-      raw_members.map do |str|
-        klass, id = str.split ':'
-        klass.classify.constantize.find_by id: id
+      raw_members.map do |serialized|
+        klass, id = serialized.split(':')
+        klass.classify.constantize.find_by(id: id)
       end
     end
-
-    private
-
-    def serialize(member)
-      WsConnectionManager.new(member).identifier
-    end
   end
 end

data/lib/loco/permissions_presenter.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Loco
+  module PermissionsPresenter
+    module_function
+
+    def indexed(loco_permissions, opts = {})
+      h = signed_in(loco_permissions).index_by do |o|
+        o.class.name.downcase.to_sym
+      end
+      if opts[:except] == :uuid
+        h.reject { |k, _| k == :string }
+      else
+        h
+      end
+    end
+
+    def signed_in(loco_permissions, opts = {})
+      arr = loco_permissions.compact
+      if opts[:except] == :uuid
+        arr.reject { |e| e.is_a?(String) }
+      else
+        arr
+      end
+    end
+  end
+end