chat_sdk 0.1.0

data/lib/chat_sdk/errors.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  class Error < StandardError; end
+  class ConfigurationError < Error; end
+
+  class NotSupportedError < Error
+    attr_reader :capability, :adapter_name
+    def initialize(capability, adapter_name)
+      @capability = capability
+      @adapter_name = adapter_name
+      super("#{adapter_name} adapter does not support #{capability}")
+    end
+  end
+
+  class LockConflictError < Error; end
+  class SignatureVerificationError < Error; end
+
+  class PlatformError < Error
+    attr_reader :status, :body, :adapter_name
+    def initialize(message, status: nil, body: nil, adapter_name: nil)
+      @status = status
+      @body = body
+      @adapter_name = adapter_name
+      super(message)
+    end
+  end
+
+  class RateLimitedError < PlatformError
+    attr_reader :retry_after
+    def initialize(message, retry_after: nil, **kwargs)
+      @retry_after = retry_after
+      super(message, **kwargs)
+    end
+  end
+
+  class DuplicateEventError < Error; end
+end

data/lib/chat_sdk/event_registry.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  class EventRegistry
+    Handler = Struct.new(:type, :matcher, :block)
+
+    def initialize
+      @handlers = []
+    end
+
+    def register(type, matcher: nil, &block)
+      @handlers << Handler.new(type: type, matcher: matcher, block: block)
+    end
+
+    def handlers_for(event)
+      @handlers.select { |h| matches?(h, event) }
+    end
+
+    private
+
+    def matches?(handler, event)
+      return false unless handler.type == event.type
+      return true if handler.matcher.nil?
+
+      case handler.matcher
+      when Regexp
+        event.respond_to?(:message) && handler.matcher.match?(event.message&.text)
+      when String
+        case event.type
+        when :action then event.action_id == handler.matcher
+        when :slash_command then event.command == handler.matcher
+        else false
+        end
+      when Array
+        event.type == :reaction && handler.matcher.include?(event.emoji)
+      else
+        false
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/action.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class Action < Base
+      attr_reader :action_id, :value, :user, :thread_id, :channel_id, :trigger_id
+
+      def initialize(action_id:, thread_id:, channel_id:, value: nil, user: nil, trigger_id: nil, **kwargs)
+        super(type: :action, **kwargs)
+        @action_id = action_id
+        @value = value
+        @user = user
+        @thread_id = thread_id
+        @channel_id = channel_id
+        @trigger_id = trigger_id
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/base.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class Base
+      attr_reader :type, :platform, :adapter_name, :raw, :timestamp
+
+      def initialize(type:, platform:, adapter_name:, raw: nil, timestamp: nil)
+        @type = type
+        @platform = platform
+        @adapter_name = adapter_name
+        @raw = raw
+        @timestamp = timestamp || Time.now
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/direct_message.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class DirectMessage < Base
+      attr_reader :message, :thread_id, :channel_id
+
+      def initialize(message:, thread_id:, channel_id:, **kwargs)
+        super(type: :direct_message, **kwargs)
+        @message = message
+        @thread_id = thread_id
+        @channel_id = channel_id
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/mention.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class Mention < Base
+      attr_reader :message, :thread_id, :channel_id
+
+      def initialize(message:, thread_id:, channel_id:, **kwargs)
+        super(type: :mention, **kwargs)
+        @message = message
+        @thread_id = thread_id
+        @channel_id = channel_id
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/reaction.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class Reaction < Base
+      attr_reader :emoji, :user_id, :message_id, :thread_id, :channel_id, :added
+
+      def initialize(emoji:, user_id:, message_id:, thread_id:, channel_id:, added: true, **kwargs)
+        super(type: :reaction, **kwargs)
+        @emoji = emoji
+        @user_id = user_id
+        @message_id = message_id
+        @thread_id = thread_id
+        @channel_id = channel_id
+        @added = added
+      end
+
+      def added?
+        @added
+      end
+
+      def removed?
+        !@added
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/slash_command.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class SlashCommand < Base
+      attr_reader :command, :text, :user_id, :channel_id, :trigger_id
+
+      def initialize(command:, user_id:, channel_id:, text: "", trigger_id: nil, **kwargs)
+        super(type: :slash_command, **kwargs)
+        @command = command
+        @text = text
+        @user_id = user_id
+        @channel_id = channel_id
+        @trigger_id = trigger_id
+      end
+    end
+  end
+end

data/lib/chat_sdk/events/subscribed_message.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Events
+    class SubscribedMessage < Base
+      attr_reader :message, :thread_id, :channel_id
+
+      def initialize(message:, thread_id:, channel_id:, **kwargs)
+        super(type: :subscribed_message, **kwargs)
+        @message = message
+        @thread_id = thread_id
+        @channel_id = channel_id
+      end
+    end
+  end
+end

data/lib/chat_sdk/log.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require "logger"
+
+module ChatSDK
+  module Log
+    class << self
+      attr_writer :logger
+
+      def logger
+        @logger ||= ::Logger.new($stdout, progname: "ChatSDK")
+      end
+
+      %i[debug info warn error fatal].each do |level|
+        define_method(level) { |msg = nil, &block| logger.send(level, msg, &block) }
+      end
+
+      def level=(level)
+        logger.level = level
+      end
+    end
+  end
+end

data/lib/chat_sdk/message.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  class Message
+    attr_reader :id, :text, :author, :thread_id, :channel_id,
+      :platform, :attachments, :raw, :timestamp
+
+    def initialize(id:, text:, author:, thread_id:, channel_id:, platform:,
+      attachments: [], raw: nil, timestamp: nil)
+      @id = id
+      @text = text
+      @author = author
+      @thread_id = thread_id
+      @channel_id = channel_id
+      @platform = platform
+      @attachments = attachments
+      @raw = raw
+      @timestamp = timestamp
+    end
+
+    def ==(other)
+      other.is_a?(Message) && id == other.id && platform == other.platform
+    end
+    alias_method :eql?, :==
+
+    def hash
+      [id, platform].hash
+    end
+  end
+end

data/lib/chat_sdk/modals/builder.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Modals
+    class Builder
+      def initialize(title:, submit_label: nil, callback_id: nil, &block)
+        @title = title
+        @submit_label = submit_label
+        @callback_id = callback_id
+        @children = []
+        instance_eval(&block) if block
+      end
+
+      def build
+        attrs = {title: @title}
+        attrs[:submit_label] = @submit_label if @submit_label
+        attrs[:callback_id] = @callback_id if @callback_id
+        ChatSDK::Cards::Node.new(:modal, attributes: attrs, children: @children)
+      end
+
+      def text_input(id:, label:, placeholder: nil, multiline: false, optional: false)
+        attrs = {id: id, label: label, input_type: :text, multiline: multiline, optional: optional}
+        attrs[:placeholder] = placeholder if placeholder
+        @children << ChatSDK::Cards::Node.new(:input, attributes: attrs)
+      end
+
+      def select_input(id:, label:, placeholder: nil, optional: false, &block)
+        ctx = ChatSDK::Cards::SelectContext.new
+        ctx.instance_eval(&block)
+        attrs = {id: id, label: label, input_type: :select, optional: optional}
+        attrs[:placeholder] = placeholder if placeholder
+        @children << ChatSDK::Cards::Node.new(:input, attributes: attrs, children: ctx.nodes)
+      end
+
+      def static_text(content)
+        @children << ChatSDK::Cards::Node.new(:text, attributes: {content: content})
+      end
+    end
+  end
+end

data/lib/chat_sdk/postable_message.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  class PostableMessage
+    attr_reader :text, :card, :attachments, :metadata
+
+    def initialize(text: nil, card: nil, attachments: [], metadata: {})
+      raise ArgumentError, "text or card required" if text.nil? && card.nil?
+      @text = text
+      @card = card
+      @attachments = attachments
+      @metadata = metadata
+    end
+
+    def card?
+      !@card.nil?
+    end
+
+    def self.from(content)
+      case content
+      when PostableMessage then content
+      when String then new(text: content)
+      when Cards::Node then new(card: content, text: content.fallback_text)
+      else raise ArgumentError, "cannot convert #{content.class} to PostableMessage"
+      end
+    end
+  end
+end

data/lib/chat_sdk/state/base.rb

@@ -0,0 +1,47 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module State
+    class Base
+      def subscribe(thread_id)
+        raise NotImplementedError
+      end
+
+      def unsubscribe(thread_id)
+        raise NotImplementedError
+      end
+
+      def subscribed?(thread_id)
+        raise NotImplementedError
+      end
+
+      def acquire_lock(key, owner:, ttl:)
+        raise NotImplementedError
+      end
+
+      def release_lock(key, owner:)
+        raise NotImplementedError
+      end
+
+      def force_lock(key, owner:, ttl:)
+        raise NotImplementedError
+      end
+
+      def get(key)
+        raise NotImplementedError
+      end
+
+      def set(key, value, ttl: nil)
+        raise NotImplementedError
+      end
+
+      def delete(key)
+        raise NotImplementedError
+      end
+
+      def set_if_absent(key, value, ttl: nil)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/chat_sdk/state/memory.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module State
+    class Memory < Base
+      def initialize
+        @mutex = Mutex.new
+        @store = {}
+        @expirations = {}
+        @subscriptions = Set.new
+        @locks = {}
+      end
+
+      def subscribe(thread_id)
+        @mutex.synchronize { @subscriptions.add(thread_id) }
+      end
+
+      def unsubscribe(thread_id)
+        @mutex.synchronize { @subscriptions.delete(thread_id) }
+      end
+
+      def subscribed?(thread_id)
+        @mutex.synchronize { @subscriptions.include?(thread_id) }
+      end
+
+      def acquire_lock(key, owner:, ttl:)
+        @mutex.synchronize do
+          expire_if_needed(key)
+          return false if @locks.key?(key)
+          @locks[key] = {owner: owner, expires_at: Time.now.to_f + ttl}
+          true
+        end
+      end
+
+      def release_lock(key, owner:)
+        @mutex.synchronize do
+          return false unless @locks[key] && @locks[key][:owner] == owner
+          @locks.delete(key)
+          true
+        end
+      end
+
+      def force_lock(key, owner:, ttl:)
+        @mutex.synchronize do
+          @locks[key] = {owner: owner, expires_at: Time.now.to_f + ttl}
+          true
+        end
+      end
+
+      def get(key)
+        @mutex.synchronize do
+          expire_if_needed(key)
+          @store[key]
+        end
+      end
+
+      def set(key, value, ttl: nil)
+        @mutex.synchronize do
+          @store[key] = value
+          @expirations[key] = Time.now.to_f + ttl if ttl
+          value
+        end
+      end
+
+      def delete(key)
+        @mutex.synchronize do
+          @store.delete(key)
+          @expirations.delete(key)
+          @locks.delete(key)
+        end
+      end
+
+      def set_if_absent(key, value, ttl: nil)
+        @mutex.synchronize do
+          expire_if_needed(key)
+          return false if @store.key?(key)
+          @store[key] = value
+          @expirations[key] = Time.now.to_f + ttl if ttl
+          true
+        end
+      end
+
+      def clear
+        @mutex.synchronize do
+          @store.clear
+          @expirations.clear
+          @subscriptions.clear
+          @locks.clear
+        end
+      end
+
+      private
+
+      def expire_if_needed(key)
+        if @expirations[key] && @expirations[key] < Time.now.to_f
+          @store.delete(key)
+          @expirations.delete(key)
+        end
+        if @locks[key] && @locks[key][:expires_at] < Time.now.to_f
+          @locks.delete(key)
+        end
+      end
+    end
+  end
+end

data/lib/chat_sdk/streaming/stream.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Streaming
+    class Stream
+      attr_reader :adapter, :channel_id, :thread_id, :update_interval
+
+      def initialize(adapter:, channel_id:, thread_id:, placeholder: nil, update_interval: 0.5)
+        @adapter = adapter
+        @channel_id = channel_id
+        @thread_id = thread_id
+        @placeholder = placeholder
+        @update_interval = update_interval
+        @buffer = +""
+        @message_id = nil
+        @last_flush_at = nil
+      end
+
+      def <<(chunk)
+        @buffer << chunk.to_s
+        maybe_flush
+        self
+      end
+
+      def run(&block)
+        post_placeholder if @placeholder
+        yield self
+        flush
+      end
+
+      private
+
+      def post_placeholder
+        result = adapter.post_message(
+          channel_id: channel_id,
+          message: PostableMessage.new(text: @placeholder),
+          thread_id: thread_id
+        )
+        @message_id = result.id if result.respond_to?(:id)
+      end
+
+      def maybe_flush
+        return unless @message_id
+        return if @last_flush_at && (Time.now.to_f - @last_flush_at) < update_interval
+
+        flush
+      end
+
+      def flush
+        return if @buffer.empty?
+
+        if @message_id && adapter.supports?(:edit_messages)
+          adapter.edit_message(
+            channel_id: channel_id,
+            message_id: @message_id,
+            message: PostableMessage.new(text: @buffer.dup)
+          )
+        elsif !@message_id
+          result = adapter.post_message(
+            channel_id: channel_id,
+            message: PostableMessage.new(text: @buffer.dup),
+            thread_id: thread_id
+          )
+          @message_id = result.id if result.respond_to?(:id)
+        end
+
+        @last_flush_at = Time.now.to_f
+      end
+    end
+  end
+end

data/lib/chat_sdk/testing/adapter_contract.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module ChatSDK
+  module Testing
+    module AdapterContract
+      RSpec.shared_examples "a chat_sdk platform adapter" do
+        it "responds to #name with a symbol" do
+          expect(subject.name).to be_a(Symbol)
+        end
+
+        it "responds to #client" do
+          expect(subject).to respond_to(:client)
+        end
+
+        it "responds to #verify_request!" do
+          expect(subject).to respond_to(:verify_request!)
+        end
+
+        it "responds to #parse_events" do
+          expect(subject).to respond_to(:parse_events)
+        end
+
+        it "responds to #post_message" do
+          expect(subject).to respond_to(:post_message)
+        end
+
+        it "responds to #mention" do
+          expect(subject).to respond_to(:mention)
+        end
+
+        it "responds to #render" do
+          expect(subject).to respond_to(:render)
+        end
+
+        it "responds to #supports?" do
+          expect(subject).to respond_to(:supports?)
+        end
+
+        it "raises NotSupportedError for undeclared capabilities" do
+          undeclared = Adapter::Capabilities::KNOWN - subject.class.declared_capabilities
+          undeclared.each do |cap|
+            method_for_cap = capability_method(cap)
+            next unless method_for_cap && subject.respond_to?(method_for_cap)
+            expect { subject.send(method_for_cap, **capability_args(cap)) }.to raise_error(NotSupportedError)
+          end
+        end
+
+        private
+
+        def capability_method(cap)
+          {
+            edit_messages: :edit_message,
+            delete_messages: :delete_message,
+            ephemeral_messages: :post_ephemeral,
+            file_uploads: :upload_file,
+            reactions: :add_reaction,
+            modals: :open_modal,
+            typing_indicator: :start_typing,
+            direct_messages: :open_dm,
+            message_history: :fetch_messages
+          }[cap]
+        end
+
+        def capability_args(cap)
+          case cap
+          when :edit_messages then {channel_id: "C1", message_id: "M1", message: PostableMessage.new(text: "t")}
+          when :delete_messages then {channel_id: "C1", message_id: "M1"}
+          when :ephemeral_messages then {channel_id: "C1", user_id: "U1", message: PostableMessage.new(text: "t")}
+          when :file_uploads then {channel_id: "C1", io: StringIO.new(""), filename: "f.txt"}
+          when :reactions then {channel_id: "C1", message_id: "M1", emoji: "thumbsup"}
+          when :modals then {trigger_id: "T1", modal: Cards::Node.new(:modal)}
+          when :typing_indicator then {channel_id: "C1"}
+          when :direct_messages then {user_id: "U1"}
+          when :message_history then {channel_id: "C1"}
+          else {}
+          end
+        end
+      end
+    end
+  end
+end