slack_bot-events 0.1.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88a291f8028f19bacd30f4c7cd8fbcbb56fdfa3463dc916289fbf6f8447df94c
-  data.tar.gz: 68aa571fdf8b0b682551621601e1cfc37128823584596aa99a9ef5130d996c6c
+  metadata.gz: c5be1bf5ab14cf6022e8a31b32015e328bd5b1939d928415bb06e610dc3e091e
+  data.tar.gz: e04f3734b913e8514f2ed50eb3f0905906013321f3fa6c26dc3992a7a5136ae4
 SHA512:
-  metadata.gz: 5488211f2ebbbdc4c5960fa03d49d859e41fce30432fb42438951ab90f6f9ccb1b410cae8fcec3dcbe86d4c2c17e5ea520eb2ec7f73eebf95192ef5092572463
-  data.tar.gz: 34d761af5cbc44e718dd44cd5ed9612e7270bbbb7f92ea88df68aceab85e23352df83fecd3b8f227155cb3e03127354dcf7bc387a2339b057890f6aab245b2f8
+  metadata.gz: 7f59e41eeb158988a8b02ba6b445b1b7ba8009e96c2ec404b313b614e9aa86d5e346518c9ad7e824b49dd29dfc4b04e9f84a827edde5698c07a3d1325b356814
+  data.tar.gz: 4e200610a557c49256745577bca3811e9830609a29009a6f4b09cc1251f972118d013c92a2a9d933e2df3391592c582112abd6911638115987bcdecf7a07fd15

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    slack_bot-events (0.1.0)
+    slack_bot-events (0.3.0)
       class_composer (~> 1.0)
       faraday
       faye-websocket

data/lib/slack_bot/events/client.rb

@@ -3,7 +3,7 @@
 require "eventmachine"
 require "faraday"
 require "faye/websocket"
-require "pry"
+require "slack_bot/events/schematize"
 
 module SlackBot
   module Events
@@ -11,54 +11,54 @@ module SlackBot
       BASE_API = "https://slack.com/api"
 
       def start!
-        EM.run do
-           websocket.on :open do |event|
-            event_tracer(:open)
+        EventMachine.run do
+           websocket.on :open do |socket_event|
+            process(type: :open, socket_event: socket_event) { |**| }
           end
 
-          websocket.on :message do |event|
-            event_tracer(:message) do
-              parsed_data = JSON.parse(event.data)
+          websocket.on :message do |socket_event|
+            process_message(socket_event: socket_event) do |parsed_data:, schema: nil|
               case parsed_data["type"]
               when "events_api"
-                events_api(parsed_data)
-              else "hello"
-                params = {
-                  num_connections: parsed_data["num_connections"],
-                  debug_info_host: parsed_data["debug_info"]["host"],
-                  debug_info_connect_time: parsed_data["debug_info"]["approximate_connection_time"],
-                }
-                event_tracer("message:hello", **params)
+                events_api(schema: schema, parsed_data: parsed_data)
               end
             end
           end
 
-          websocket.on :close do |event|
-            event_tracer(:close, code: event.code, reason: event.reason)
+          websocket.on :close do |socket_event|
+            process(type: :close, socket_event: socket_event) { |**| }
             @websocket = nil
+
+            # The websocket is closed, explcitly stop the event machine to to end the loop and return to the parent
+            EventMachine.stop
           end
         end
       end
 
-      def events_api(parsed_data)
-        schematized = SlackBot::Events::Schemas::SocketPayload.new(parsed_data)
-        Events.logger.info(schematized.tldr) if Events.config.print_tldr
-        object = Events.config.listeners[schematized.type.to_sym]
-        if object
-          safe_handler(type: schematized.type.to_sym, object: object, schema: schematized, parsed_data: parsed_data)
+      def process_message(socket_event:)
+        schema_data = Schematize.call(data: socket_event.data)
+        SlackBot::Events.message_middleware.invoke_message(type: :message, socket_event: socket_event, **schema_data) do
+          yield(**schema_data) if block_given?
+        end
+      end
+
+      def process(type:, socket_event:)
+        SlackBot::Events.public_send(:"#{type}_middleware").invoke(type: type, socket_event: socket_event) do
+          yield if block_given?
         end
-        websocket.send("#{{ envelope_id: schematized.envelope_id }.to_json}")
       end
 
-      def event_tracer(type, **params)
-        stringify = params.map { |k,v| "#{k}:#{v}" }.join("; ")
-        Events.logger.info "[Event Received] #{type} #{stringify}"
-        if block_given?
-          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
-          yield
-          elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
-          Events.logger.info "[Event completed] [#{elapsed_time.round(2)}s] #{type} #{stringify}"
+      def events_api(schema:, parsed_data:)
+        if Events.config.print_tldr
+          Events.logger.info { schema.tldr }
         end
+
+        object = Events.config.listeners[schema.type.to_sym]
+        if object
+          safe_handler(type: schema.type.to_sym, object: object, schema: schema, parsed_data: parsed_data)
+        end
+
+        websocket.send("#{{ envelope_id: schema.envelope_id }.to_json}")
       end
 
       private

data/lib/slack_bot/events/configuration.rb

@@ -2,17 +2,29 @@
 
 require "class_composer"
 require "logger"
+require "slack_bot/events/middleware/chain"
 
 module SlackBot
   module Events
     class Configuration
       include ClassComposer::Generator
+
+      ALLOWED_ACKNOWLEDGE = [
+        DEFAULT_ACKNOWLEDGE = :on_complete,
+        :on_success,
+        :on_receive,
+      ]
+
       add_composer :client_id, allowed: String, default: ENV["SLACK_CLIENT_ID"]
       add_composer :client_secret, allowed: String, default: ENV["SLACK_CLIENT_SECRET"]
       add_composer :client_signing_secret, allowed: String, default: ENV["SLACK_SIGNING_SECRET"]
       add_composer :client_socket_token, allowed: String, default: ENV["SLACK_SOCKET_TOKEN"]
       add_composer :client_verification_token, allowed: String, default: ENV["SLACK_VERIFICATION_TOKEN"]
       add_composer :print_tldr, allowed: [true.class, false.class], default: true
+      add_composer :message_middleware, allowed: Middleware::Chain, default: Middleware::Chain.new(type: :message)
+      add_composer :open_middleware, allowed: Middleware::Chain, default: Middleware::Chain.new(type: :open)
+      add_composer :close_middleware, allowed: Middleware::Chain, default: Middleware::Chain.new(type: :close)
+      add_composer :envelope_acknowledge, allowed: Symbol, default: DEFAULT_ACKNOWLEDGE, validator: ->(val) { ALLOWED_ACKNOWLEDGE.include?(val) }, invalid_message: ->(_) { "Must by a Symbol in #{ALLOWED_ACKNOWLEDGE}" }
 
       def register_listener(name:, handler:, on_success: nil, on_failure: nil)
         if event_handler = listeners[name.to_sym]

data/lib/slack_bot/events/middleware/chain.rb

@@ -0,0 +1,147 @@
+# frozen_string_literal: true
+
+require "slack_bot/events/middleware/event_tracer"
+
+####################
+#
+# Adapted from Sidekiq:
+# https://github.com/sidekiq/sidekiq/blob/main/lib/sidekiq/middleware/chain.rb
+#
+####################
+
+module SlackBot
+  module Events
+    module Middleware
+      class Chain
+        include Enumerable
+
+        attr_reader :type
+
+        DEFAULT_ENTRIES = {
+          message: [Middleware::EventTracer],
+          open: [Middleware::EventTracer],
+          close: [Middleware::EventTracer],
+        }
+
+        def initialize(type:)
+          @type = type
+        end
+
+        def self.default_entry(type)
+          DEFAULT_ENTRIES[type].map { Entry.new(_1) }
+        end
+
+        def entries
+          @entries ||= self.class.default_entry(type)
+        end
+
+        def remove(klass)
+          raise ArgumentError, "Unable to remove default Middleware #{klass}" if self.class.default_entry.map(:klass).include?(klass)
+
+          entries.delete_if { |entry| entry.klass == klass }
+        end
+
+        def add(klass, *args)
+          remove(klass)
+          entries << Entry.new(klass, args)
+        end
+
+        def prepend(klass, *args)
+          remove(klass)
+          entries.insert(0, Entry.new(klass, args))
+        end
+
+        def insert_before(oldklass, newklass, *args)
+          i = entries.index { |entry| entry.klass == newklass }
+          new_entry = i.nil? ? Entry.new(klass, args) : entries.delete_at(i)
+          i = entries.index { |entry| entry.klass == oldklass } || 0
+          entries.insert(i, new_entry)
+        end
+
+        def insert_after(oldklass, newklass, *args)
+          i = entries.index { |entry| entry.klass == newklass }
+          new_entry = i.nil? ? Entry.new(klass, args) : entries.delete_at(i)
+          i = entries.index { |entry| entry.klass == oldklass } || entries.count - 1
+          entries.insert(i + 1, new_entry)
+        end
+
+        def exists?(klass)
+          any? { |entry| entry.klass == klass }
+        end
+
+        def empty?
+          entries.nil? || entries.empty?
+        end
+
+        def retrieve
+          map(&:instance!)
+        end
+
+        def each(&block)
+          entries.each(&block)
+        end
+
+        def clear
+          @entries = nil
+        end
+
+        def invoke_message(type:, socket_event:, parsed_data:, schema: nil)
+          return yield if empty?
+
+          chain = retrieve
+          traverse_chain = proc do
+            if chain.empty?
+              yield(yield: schema, parsed_data: parsed_data)
+            else
+              params = {
+                parsed_data: parsed_data,
+                schema: schema,
+                socket_event: socket_event,
+                type: type,
+              }
+              chain.shift.call(**params, &traverse_chain)
+            end
+          end
+          traverse_chain.call
+        end
+
+        def invoke(type:, socket_event:)
+          return yield if empty?
+
+          chain = retrieve
+          traverse_chain = proc do
+            if chain.empty?
+              yield
+            else
+              chain.shift.call(type: type, socket_event: socket_event, &traverse_chain)
+            end
+          end
+          traverse_chain.call
+        end
+
+        def inspect_me
+          entries.map do |e|
+            [
+              e.klass,
+              e.args
+            ]
+          end
+        end
+      end
+
+      class Entry
+        attr_reader :klass
+        attr_reader :args
+
+        def initialize(klass, args = [])
+          @klass = klass
+          @args = args
+        end
+
+        def instance!
+          klass.new(*args)
+        end
+      end
+    end
+  end
+end

data/lib/slack_bot/events/middleware/event_tracer.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module SlackBot
+  module Events
+    module Middleware
+      class EventTracer
+        def call(type:, socket_event:, schema: nil, parsed_data: nil)
+          start_time = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+          temp_type = type.dup.to_s
+          case type
+          when :close
+            additional_info = "code: #{socket_event.code} reason:#{socket_event.reason}"
+          when :message
+            p_type = parsed_data.dig("type")
+            case p_type
+            when "app_rate_limited"
+              # https://api.slack.com/apis/rate-limits#events
+              # Total allowed workspace events are 30,000 per hour
+              # This message type is received once you have gone beyond that
+              temp_type += ":#{p_type}"
+              additional_info = "minute_rate_limited:#{parsed_data["minute_rate_limited"]} " \
+                "team_id:#{parsed_data["team_id"]} " \
+                "api_app_id:#{parsed_data["api_app_id"]}"
+            else
+              # Expected other types are `events_api` and `hello`
+              temp_type += ":#{p_type}"
+            end
+          end
+
+          Events.logger.info { "[Event Received] #{temp_type} #{additional_info}" }
+
+          yield
+
+          elapsed_time = Process.clock_gettime(Process::CLOCK_MONOTONIC) - start_time
+          Events.logger.info { "[Event Finished] [#{(elapsed_time * 1000).round(2)}ms] #{temp_type}" }
+        end
+      end
+    end
+  end
+end

data/lib/slack_bot/events/schemas/socket_payload.rb

@@ -28,7 +28,7 @@ module SlackBot
         def tldr
           retry_language = "#{retry_attempt}"
           retry_language += ":#{retry_reason}" if retry_attempt > 0
-          "tldr:#{payload.event.tldr}; retry:#{retry_language}"
+          "#{payload.event.tldr}; retry:#{retry_language}"
         end
       end
     end

data/lib/slack_bot/events/schemas/type/bot_profile.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "json_schematize"
+require "json_schematize/generator"
+
+module SlackBot
+  module Events
+    module Schemas
+      module Type
+        class BotProfile < JsonSchematize::Generator
+          schema_default option: :dig_type, value: :string
+
+          add_field name: :id, type: String
+          add_field name: :app_id, type: String
+          add_field name: :name, type: String
+          add_field name: :deleted, type: JsonSchematize::Boolean
+          add_field name: :updated, type: String
+          add_field name: :team_id, type: String
+        end
+      end
+    end
+  end
+end

data/lib/slack_bot/events/schemas/type/message.rb

@@ -4,6 +4,7 @@ require "json_schematize"
 require "json_schematize/generator"
 
 require "slack_bot/events/schemas/type/block"
+require "slack_bot/events/schemas/type/bot_profile"
 
 module SlackBot
   module Events
@@ -20,6 +21,7 @@ module SlackBot
           add_field name: :team, type: String
 
           add_field name: :blocks, type: SlackBot::Events::Schemas::Type::Block, array_of_types: true
+          add_field name: :bot_profile, type: SlackBot::Events::Schemas::Type::BotProfile, required: false
 
           add_field name: :thread_ts, type: String, required: false
           add_field name: :parent_user_id, type: String, required: false
@@ -28,8 +30,16 @@ module SlackBot
           add_field name: :event_ts, type: String
           add_field name: :channel_type, type: String
 
+          def made_from_user?
+            bot_profile.nil? || JsonSchematize::EmptyValue === bot_profile
+          end
+
+          def made_from_bot?
+            !made_from_user?
+          end
+
           def tldr
-            "type: #{type}; channel:#{channel}; raw_text:#{text}"
+            "type:#{type}; user:#{user}; channel:#{channel}; ts_id:#{combined_id}"
           end
 
           def thread_ts
@@ -42,6 +52,10 @@ module SlackBot
 
           private
 
+          def combined_id
+            thread_ts ? "#{ts}:#{thread_ts}" : ts
+          end
+
           def return_nil?(val)
             JsonSchematize::EmptyValue === val || val.nil?
           end

data/lib/slack_bot/events/schemas/type/reaction_modified.rb

@@ -28,7 +28,7 @@ module SlackBot
           end
 
           def tldr
-            "type: #{type}; channel:#{channel}; reaction:#{reaction}"
+            "type:#{type}; user:#{item_user}; channel:#{channel}; reaction:#{reaction}"
           end
         end
       end

data/lib/slack_bot/events/schematize.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module SlackBot
+  module Events
+    module Schematize
+      def self.message(parsed_data)
+        case parsed_data["type"]
+        when "events_api"
+          return SlackBot::Events::Schemas::SocketPayload
+        when "app_rate_limited"
+        when "hello"
+        end
+      end
+
+      def self.call(data:)
+        parsed_data = JSON.parse(data)
+        return { parsed_data: parsed_data } unless schema_klass = message(parsed_data)
+
+        if schema_klass.respond_to?(:call)
+          { schema: schema_klass.call(parsed_data).new(parsed_data), parsed_data: parsed_data }
+        else
+          { schema: schema_klass.new(parsed_data), parsed_data: parsed_data }
+        end
+      end
+    end
+  end
+end

data/lib/slack_bot/events/version.rb

@@ -2,6 +2,6 @@
 
 module SlackBot
   module Events
-    VERSION = "0.1.0"
+    VERSION = "0.3.0"
   end
 end

data/lib/slack_bot/events.rb

@@ -1,7 +1,10 @@
 # frozen_string_literal: true
 
+require "pry"
+
 require "slack_bot/events/configuration"
 require "slack_bot/events/client"
+require "slack_bot/events/middleware/chain"
 require "slack_bot/events/schemas/socket_payload"
 
 module SlackBot
@@ -40,5 +43,17 @@ module SlackBot
     def self.logger
       config.logger
     end
+
+    def self.message_middleware
+      config.message_middleware
+    end
+
+    def self.open_middleware
+      config.open_middleware
+    end
+
+    def self.close_middleware
+      config.close_middleware
+    end
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: slack_bot-events
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.3.0
 platform: ruby
 authors:
 - Matt Taylor
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2024-06-18 00:00:00.000000000 Z
+date: 2024-06-20 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: faraday
@@ -134,15 +134,19 @@ files:
 - lib/slack_bot/events.rb
 - lib/slack_bot/events/client.rb
 - lib/slack_bot/events/configuration.rb
+- lib/slack_bot/events/middleware/chain.rb
+- lib/slack_bot/events/middleware/event_tracer.rb
 - lib/slack_bot/events/schemas/authorization.rb
 - lib/slack_bot/events/schemas/data_payload.rb
 - lib/slack_bot/events/schemas/socket_payload.rb
 - lib/slack_bot/events/schemas/type/base.rb
 - lib/slack_bot/events/schemas/type/block.rb
+- lib/slack_bot/events/schemas/type/bot_profile.rb
 - lib/slack_bot/events/schemas/type/element.rb
 - lib/slack_bot/events/schemas/type/item.rb
 - lib/slack_bot/events/schemas/type/message.rb
 - lib/slack_bot/events/schemas/type/reaction_modified.rb
+- lib/slack_bot/events/schematize.rb
 - lib/slack_bot/events/version.rb
 - slack_bot-events.gemspec
 homepage: https://github.com/matt-taylor/slack_bot-events