pub_sub_model_sync 0.2.2 → 0.4.0

data/README.md

@@ -67,7 +67,7 @@ And then execute: $ bundle install
 # attributes: name email age 
 class User < ActiveRecord::Base
   include PubSubModelSync::PublisherConcern
-  ps_publish(%i[name email])
+  ps_publish(%i[id name email])
 end
 
 # App 2 (Subscriber)
@@ -86,7 +86,7 @@ User.create(name: 'test user', email: 'sample@gmail.com') # Review your App 2 to
 User.new(name: 'test user').ps_perform_sync(:create) # similar to above to perform sync on demand
 
 User.ps_class_publish({ msg: 'Hello' }, action: :greeting) # User.greeting method (Class method) will be called in App2
-PubSubModelSync::Publisher.new.publish_data(User, { msg: 'Hello' }, :greeting) # similar to above when not included publisher concern
+PubSubModelSync::MessagePublisher.publish_data(User, { msg: 'Hello' }, :greeting) # similar to above when not included publisher concern
 ```
 
 ## Advanced Example
@@ -95,60 +95,117 @@ PubSubModelSync::Publisher.new.publish_data(User, { msg: 'Hello' }, :greeting) #
 class User < ActiveRecord::Base
   self.table_name = 'publisher_users'
   include PubSubModelSync::PublisherConcern
-  ps_publish(%i[name:full_name email], actions: %i[update], as_klass: 'Client', id: :client_id)
+  ps_publish(%i[id:client_id name:full_name email], actions: %i[update], as_klass: 'Client')
   
-  def ps_skip_for?(_action)
+  def ps_skip_callback?(_action)
     false # here logic with action to skip push message
   end
+  
+  def ps_skip_sync?(_action)
+      false # here logic with action to skip push message
+    end
 end
 
 # App 2 (Subscriber)
 class User < ActiveRecord::Base
   self.table_name = 'subscriber_users'
   include PubSubModelSync::SubscriberConcern
-  ps_subscribe(%i[name], actions: %i[update], as_klass: 'Client', id: :custom_id)
-  ps_class_subscribe(:greeting, as_action: :custom_greeting, as_klass: 'CustomUser')
+  ps_subscribe(%i[name], actions: %i[update], from_klass: 'Client', id: %i[client_id email])
+  ps_class_subscribe(:greeting, from_action: :custom_greeting, from_klass: 'CustomUser')
+  alias_attribute :full_name, :name
   
   def self.greeting(data)
     puts 'Class message called through custom_greeting'
   end
+  
+  # def self.ps_find_model(data, settings)
+  #   where(email: data[:email], ...).first_or_initialize 
+  # end
 end
 ```
 
+Note: Be careful with collision of names
+```
+class User
+    # ps_publish %i[name_data:name name:key] # key will be replaced with name_data 
+    ps_publish %i[name_data:name key_data:key] # use alias to avoid collision
+    
+    def key_data
+      name
+    end
+end
+``` 
+
 ## API
-- To perform a callback before publishing message (CRUD)
+### Subscribers
+- Permit to configure class level listeners
+  ```ps_class_subscribe(action_name, from_action: nil, from_klass: nil)```
+  * from_action: (Optional) Source method name
+  * from_klass: (Optional) Source class name
+  
+- Permit to configure instance level listeners (CRUD)
+  ```ps_subscribe(attrs, from_klass: nil, actions: nil, id: nil)```
+  * attrs: (Array/Required) Array of all attributes to be synced
+  * from_klass: (String/Optional) Source class name (Instead of the model class name, will use this value) 
+  * actions: (Array/Optional, default: create/update/destroy) permit to customize action names
+  * id: (Sym|Array/Optional, default: id) Attr identifier(s) to find the corresponding model
+
+- Permit to configure a custom model finder
+  ```ps_find_model(data, settings)```
+  * data: (Hash) Data received from sync
+  * settings: (Hash(:klass, :action)) Class and action name from sync
+  Must return an existent or a new model object
+
+- Get crud subscription configured for the class   
+  ```User.ps_subscriber(action_name)```  
+  * action_name (default :create, :sym): can be :create, :update, :destroy
+
+- Inspect all configured listeners
+  ```PubSubModelSync::Config.listeners```    
+
+### Publishers
+- Permit to configure crud publishers
+  ```ps_publish(attrs, actions: nil, as_klass: nil)```
+  * attrs: (Array/Required) Array of attributes to be published
+  * actions: (Array/Optional, default: create/update/destroy) permit to customize action names
+  * as_klass: (String/Optional) Output class name (Instead of the model class name, will use this value)
+
+- Permit to cancel sync called after create/update/destroy (Before initializing sync service)
+  ```model.ps_skip_callback?(action)```    
+  Note: Return true to cancel sync
+  
+- Callback called before preparing data for sync (Permit to stop sync)
+  ```model.ps_skip_sync?(action)```     
+  Note: return true to cancel sync
+  
+- Callback called before sync (After preparing data)
   ```model.ps_before_sync(action, data_to_deliver)```  
-  Note: If the method returns ```false```, the message will not be published
+  Note: If the method returns ```:cancel```, the sync will be stopped (message will not be published)
 
-- To perform a callback after publishing message (CRUD)
-  ```model.ps_after_sync(action, data_to_deliver)```  
-  Note: If the method returns ```false```, the message will not be published  
+- Callback called after sync
+  ```model.ps_after_sync(action, data_delivered)```  
 
 - Perform sync on demand (:create, :update, :destroy):   
   The target model will receive a notification to perform the indicated action  
-  ```my_model.ps_perform_sync(action_name)```
+  ```my_model.ps_perform_sync(action_name, custom_settings = {})```  
+  * custom_settings: override default settings defined for action_name ({ attrs: [], as_klass: nil })
     
-- Class level notification:     
+- Publish a class level notification:     
   ```User.ps_class_publish(data, action: action_name, as_klass: custom_klass_name)```
   Target class ```User.action_name``` will be called when message is received    
   * data: (required, :hash) message value to deliver    
-  * action_name: (required, :sim) same action name as defined in ps_class_subscribe(...)    
-  * as_klass: (optional, :string) same class name as defined in ps_class_subscribe(...)
+  * action_name: (required, :sim) Action name    
+  * as_klass: (optional, :string) Custom class name (Default current model name)
       
-- Class level notification (Same as above: on demand call)    
-  ```PubSubModelSync::Publisher.new.publish_data(Klass_name, data, action_name)```  
+- Publish a class level notification (Same as above: on demand call)    
+  ```PubSubModelSync::MessagePublisher.publish_data(Klass_name, data, action_name)```  
   * klass_name: (required, Class) same class name as defined in ps_class_subscribe(...)
   * data: (required, :hash) message value to deliver    
   * action_name: (required, :sim) same action name as defined in ps_class_subscribe(...)
   
-- Get crud subscription configured for the class   
-  ```User.ps_subscriber(action_name)```  
-  * action_name (default :create, :sym): can be :create, :update, :destroy
 - Get crud publisher configured for the class   
   ```User.ps_publisher(action_name)```  
   * action_name (default :create, :sym): can be :create, :update, :destroy
-- Inspect all configured listeners
-  ```PubSubModelSync::Config.listeners```
   
 ## Testing with RSpec
 - Config: (spec/rails_helper.rb)
@@ -181,12 +238,10 @@ end
     # Subscriber
     it 'receive model message' do
       action = :create
-      data = { name: 'name' }
-      user_id = 999
-      attrs = PubSubModelSync::Publisher.build_attrs('User', action, user_id)
-      publisher = PubSubModelSync::MessageProcessor.new(data, 'User', action, id: user_id)
+      data = { name: 'name', id: 999 }
+      publisher = PubSubModelSync::MessageProcessor.new(data, 'User', action)
       publisher.process
-      expect(User.where(id: user_id).any?).to be_truth
+      expect(User.where(id: data[:id]).any?).to be_truth
     end
       
     it 'receive class message' do
@@ -199,20 +254,20 @@ end
   
     # Publisher
     it 'publish model action' do
-      publisher = PubSubModelSync::Publisher  
+      publisher = PubSubModelSync::MessagePublisher  
       data = { name: 'hello'}
       action = :create
       User.ps_class_publish(data, action: action)
       user = User.create(name: 'name', email: 'email')
-      expect_any_instance_of(publisher).to receive(:publish_model).with(user, :create, anything)
+      expect(publisher).to receive(:publish_model).with(user, :create, anything)
     end
        
     it 'publish class message' do
-      publisher = PubSubModelSync::Publisher  
+      publisher = PubSubModelSync::MessagePublisher  
       data = {msg: 'hello'}
       action = :greeting
       User.ps_class_publish(data, action: action)
-      expect_any_instance_of(publisher).to receive(:publish_data).with('User', data, action)
+      expect(publisher).to receive(:publish_data).with('User', data, action)
     end
     ```
 

data/lib/pub_sub_model_sync.rb

@@ -6,12 +6,15 @@ require 'active_support'
 require 'pub_sub_model_sync/railtie'
 require 'pub_sub_model_sync/config'
 require 'pub_sub_model_sync/subscriber_concern'
-require 'pub_sub_model_sync/publisher'
+require 'pub_sub_model_sync/message_publisher'
 require 'pub_sub_model_sync/publisher_concern'
 require 'pub_sub_model_sync/runner'
 require 'pub_sub_model_sync/connector'
 require 'pub_sub_model_sync/message_processor'
 
+require 'pub_sub_model_sync/publisher'
+require 'pub_sub_model_sync/subscriber'
+
 require 'pub_sub_model_sync/service_base'
 require 'pub_sub_model_sync/service_google'
 require 'pub_sub_model_sync/service_rabbit'

data/lib/pub_sub_model_sync/config.rb

@@ -2,7 +2,7 @@
 
 module PubSubModelSync
   class Config
-    cattr_accessor(:listeners) { [] }
+    cattr_accessor(:subscribers) { [] }
     cattr_accessor(:publishers) { [] }
     cattr_accessor(:service_name) { :google }
     cattr_accessor :logger

data/lib/pub_sub_model_sync/connector.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require 'google/cloud/pubsub'
 module PubSubModelSync
   class Connector
     attr_accessor :service

data/lib/pub_sub_model_sync/message_processor.rb

@@ -2,79 +2,39 @@
 
 module PubSubModelSync
   class MessageProcessor
-    attr_accessor :data, :attrs, :settings
+    attr_accessor :data, :klass, :action
 
     # @param data (Hash): any hash value to deliver
-    # @param settings (optional): { id: id_val }
-    def initialize(data, klass, action, settings = {})
+    def initialize(data, klass, action)
       @data = data
-      @settings = settings
-      @attrs = settings.merge(klass: klass, action: action)
+      @klass = klass
+      @action = action
     end
 
     def process
-      log 'processing message'
-      listeners = filter_listeners
-      eval_message(listeners) if listeners.any?
-      log 'processed message'
+      subscribers = filter_subscribers
+      subscribers.each { |subscriber| run_subscriber(subscriber) }
     end
 
     private
 
-    def eval_message(listeners)
-      listeners.each do |listener|
-        if listener[:direct_mode]
-          call_class_listener(listener)
-        else
-          call_listener(listener)
-        end
-      end
-    end
-
-    def call_class_listener(listener)
-      model_class = listener[:klass].constantize
-      model_class.send(listener[:action], data)
-    rescue => e
-      log("Error listener (#{listener}): #{e.message}", :error)
-    end
-
-    # support for: create, update, destroy
-    def call_listener(listener)
-      model = find_model(listener)
-      if attrs[:action].to_sym == :destroy
-        model.destroy!
-      else
-        populate_model(model, listener)
-        model.save!
-      end
+    def run_subscriber(subscriber)
+      subscriber.eval_message(data)
+      log "processed message with: #{[klass, action, data]}"
     rescue => e
-      log("Error listener (#{listener}): #{e.message}", :error)
-    end
-
-    def find_model(listener)
-      model_class = listener[:klass].constantize
-      identifier = listener[:settings][:id] || :id
-      model_class.where(identifier => attrs[:id]).first ||
-        model_class.new(identifier => attrs[:id])
-    end
-
-    def populate_model(model, listener)
-      values = data.slice(*listener[:settings][:attrs])
-      values.each do |attr, value|
-        model.send("#{attr}=", value)
-      end
+      info = [klass, action, data, e.message, e.backtrace]
+      log("error processing message: #{info}", :error)
     end
 
-    def filter_listeners
-      listeners = PubSubModelSync::Config.listeners
-      listeners.select do |listener|
-        listener[:as_klass].to_s == attrs[:klass].to_s &&
-          listener[:as_action].to_s == attrs[:action].to_s
+    def filter_subscribers
+      PubSubModelSync::Config.subscribers.select do |subscriber|
+        subscriber.settings[:from_klass].to_s == klass.to_s &&
+          subscriber.settings[:from_action].to_s == action.to_s
       end
     end
 
     def log(message, kind = :info)
-      PubSubModelSync::Config.log "#{message} ==> #{[data, attrs]}", kind
+      PubSubModelSync::Config.log message, kind
     end
   end
 end

data/lib/pub_sub_model_sync/message_publisher.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+module PubSubModelSync
+  class MessagePublisher
+    class << self
+      delegate :publish, to: :connector
+
+      def connector
+        @connector ||= PubSubModelSync::Connector.new
+      end
+
+      def publish_data(klass, data, action)
+        attrs = { klass: klass.to_s, action: action.to_sym }
+        publish(data, attrs)
+      end
+
+      # @param model: ActiveRecord model
+      # @param action: (Sym) Action name
+      # @param publisher: (Publisher, optional) Publisher to be used
+      def publish_model(model, action, publisher = nil)
+        return if model.ps_skip_sync?(action)
+
+        publisher ||= model.class.ps_publisher(action)
+        payload = publisher.payload(model, action)
+        res_before = model.ps_before_sync(action, payload[:data])
+        return if res_before == :cancel
+
+        publish(payload[:data], payload[:attrs])
+        model.ps_after_sync(action, payload[:data])
+      end
+    end
+  end
+end

data/lib/pub_sub_model_sync/mock_rabbit_service.rb

@@ -30,6 +30,10 @@ module PubSubModelSync
       def topic(*_args)
         @topic ||= MockTopic.new
       end
+
+      def close
+        true
+      end
     end
 
     def create_channel(*_args)

data/lib/pub_sub_model_sync/publisher.rb

@@ -2,43 +2,24 @@
 
 module PubSubModelSync
   class Publisher
-    attr_accessor :connector
-    def initialize
-      @connector = PubSubModelSync::Connector.new
+    attr_accessor :attrs, :actions, :klass, :as_klass
+    def initialize(attrs, klass, actions = nil, as_klass = nil)
+      @attrs = attrs
+      @klass = klass
+      @actions = actions || %i[create update destroy]
+      @as_klass = as_klass || klass
     end
 
-    def publish_data(klass, data, action)
-      attributes = self.class.build_attrs(klass, action)
-      connector.publish(data, attributes)
-    end
-
-    # @param settings (Hash): { attrs: [], as_klass: nil, id: nil }
-    def publish_model(model, action, settings = nil)
-      settings ||= model.class.ps_publisher_info(action)
-      attributes = build_model_attrs(model, action, settings)
-      data = {}
-      data = build_model_data(model, settings[:attrs]) if action != :destroy
-      res_before = model.ps_before_sync(action, data)
-      return if res_before == false
-
-      connector.publish(data.symbolize_keys, attributes)
-      model.ps_after_sync(action, data)
-    end
-
-    def self.build_attrs(klass, action, id = nil)
-      {
-        klass: klass.to_s,
-        action: action.to_sym,
-        id: id
-      }
+    def payload(model, action)
+      { data: payload_data(model), attrs: payload_attrs(model, action) }
     end
 
     private
 
-    def build_model_data(model, model_props)
-      source_props = model_props.map { |prop| prop.to_s.split(':').first }
+    def payload_data(model)
+      source_props = @attrs.map { |prop| prop.to_s.split(':').first }
       data = model.as_json(only: source_props, methods: source_props)
-      aliased_props = model_props.select { |prop| prop.to_s.include?(':') }
+      aliased_props = @attrs.select { |prop| prop.to_s.include?(':') }
       aliased_props.each do |prop|
         source, target = prop.to_s.split(':')
         data[target] = data.delete(source)
@@ -46,14 +27,8 @@ module PubSubModelSync
       data.symbolize_keys
     end
 
-    def build_model_attrs(model, action, settings)
-      as_klass = (settings[:as_klass] || model.class.name).to_s
-      id_val = model.send(settings[:id] || :id)
-      self.class.build_attrs(as_klass, action, id_val)
-    end
-
-    def log(msg)
-      PubSubModelSync::Config.log(msg)
+    def payload_attrs(model, action)
+      { klass: (as_klass || model.class.name).to_s, action: action.to_sym }
     end
   end
 end

data/lib/pub_sub_model_sync/publisher_concern.rb

@@ -6,54 +6,66 @@ module PubSubModelSync
       base.extend(ClassMethods)
     end
 
-    # Permit to skip a publish callback
-    def ps_skip_for?(_action)
+    # Before initializing sync service (callbacks: after create/update/destroy)
+    def ps_skip_callback?(_action)
       false
     end
 
+    # before preparing data to sync
+    def ps_skip_sync?(_action)
+      false
+    end
+
+    # before delivering data
     def ps_before_sync(_action, _data); end
 
+    # after delivering data
     def ps_after_sync(_action, _data); end
 
-    def ps_perform_sync(action = :create)
-      service = self.class.ps_publisher_service
-      service.publish_model(self, action, self.class.ps_publisher_info(action))
+    # To perform sync on demand
+    # @param attrs (Array, optional): custom attrs to be used
+    # @param as_klass (Array, optional): custom klass name to be used
+    # @param publisher (Publisher, optional): custom publisher object
+    def ps_perform_sync(action = :create, attrs: nil, as_klass: nil,
+                        publisher: nil)
+      publisher ||= self.class.ps_publisher(action).dup
+      publisher.attrs = attrs if attrs
+      publisher.as_klass = as_klass if as_klass
+      PubSubModelSync::MessagePublisher.publish_model(self, action, publisher)
     end
 
     module ClassMethods
-      # Permit to publish crud actions (:create, :update, :destroy)
-      # @param settings (Hash): { actions: nil, as_klass: nil, id: nil }
-      def ps_publish(attrs, settings = {})
-        actions = settings.delete(:actions) || %i[create update destroy]
+      # Permit to configure to publish crud actions (:create, :update, :destroy)
+      def ps_publish(attrs, actions: %i[create update destroy], as_klass: nil)
+        klass = PubSubModelSync::Publisher
+        publisher = klass.new(attrs, name, actions, as_klass)
+        PubSubModelSync::Config.publishers << publisher
         actions.each do |action|
-          info = settings.merge(klass: name, action: action, attrs: attrs)
-          PubSubModelSync::Config.publishers << info
-          ps_register_callback(action.to_sym, info)
+          ps_register_callback(action.to_sym, publisher)
         end
       end
 
-      def ps_publisher_info(action = :create)
-        PubSubModelSync::Config.publishers.select do |listener|
-          listener[:klass] == name && listener[:action] == action
-        end.last
-      end
-
+      # On demand class level publisher
       def ps_class_publish(data, action:, as_klass: nil)
         as_klass = (as_klass || name).to_s
-        ps_publisher_service.publish_data(as_klass, data, action.to_sym)
+        klass = PubSubModelSync::MessagePublisher
+        klass.publish_data(as_klass, data, action.to_sym)
       end
 
-      def ps_publisher_service
-        PubSubModelSync::Publisher.new
+      # Publisher info for specific action
+      def ps_publisher(action = :create)
+        PubSubModelSync::Config.publishers.find do |publisher|
+          publisher.klass == name && publisher.actions.include?(action)
+        end
       end
 
       private
 
-      def ps_register_callback(action, info)
+      def ps_register_callback(action, publisher)
         after_commit(on: action) do |model|
-          unless model.ps_skip_for?(action)
-            service = model.class.ps_publisher_service
-            service.publish_model(model, action.to_sym, info)
+          unless model.ps_skip_callback?(action)
+            klass = PubSubModelSync::MessagePublisher
+            klass.publish_model(model, action.to_sym, publisher)
           end
         end
       end