igniter 0.4.5 → 0.5.1

data/packages/igniter-sdk/lib/igniter/sdk/channels/webhook.rb

@@ -0,0 +1,213 @@
+# frozen_string_literal: true
+
+require "json"
+require "net/http"
+require "uri"
+
+module Igniter
+  module Channels
+    class Webhook < Base
+      DEFAULT_OPEN_TIMEOUT = 10
+      DEFAULT_READ_TIMEOUT = 30
+      BODY_METHODS = %i[post put patch].freeze
+
+      effect_type :webhook
+      channel_name :webhook
+
+      def initialize(url: nil, method: :post, headers: {}, params: nil,
+                     open_timeout: DEFAULT_OPEN_TIMEOUT, read_timeout: DEFAULT_READ_TIMEOUT,
+                     basic_auth: nil)
+        @url = url
+        @method = method.to_sym
+        @headers = (headers || {}).dup.freeze
+        @params = params
+        @open_timeout = open_timeout
+        @read_timeout = read_timeout
+        @basic_auth = basic_auth
+      end
+
+      private
+
+      def deliver_message(message)
+        uri = build_uri(message)
+        request = build_request(message, uri)
+        response = perform_request(uri, request)
+
+        unless response.is_a?(Net::HTTPSuccess)
+          raise DeliveryError.new(
+            "Webhook delivery failed with HTTP #{response.code}",
+            context: {
+              channel: self.class.channel_name,
+              recipient: message.to || @url,
+              status_code: response.code.to_i,
+              response_body: response.body.to_s[0, 300]
+            }
+          )
+        end
+
+        DeliveryResult.new(
+          status: delivery_status_for(response),
+          provider: self.class.channel_name,
+          recipient: message.to || @url,
+          external_id: response["x-request-id"] || response["x-correlation-id"],
+          payload: {
+            status_code: response.code.to_i,
+            headers: response.to_hash,
+            body: parse_response_body(response.body)
+          }
+        )
+      rescue URI::InvalidURIError => e
+        raise DeliveryError.new(
+          "Invalid webhook URL: #{e.message}",
+          context: { channel: self.class.channel_name, recipient: message.to || @url }
+        )
+      rescue Errno::ECONNREFUSED, Errno::EADDRNOTAVAIL, SocketError, Net::OpenTimeout, Net::ReadTimeout => e
+        raise DeliveryError.new(
+          "Cannot deliver webhook: #{e.message}",
+          context: { channel: self.class.channel_name, recipient: message.to || @url }
+        )
+      end
+
+      def build_uri(message)
+        destination = message.to || @url
+        raise ArgumentError, "Webhook destination URL is required" if destination.nil? || destination.to_s.empty?
+
+        uri = URI.parse(destination)
+        merged_query = merge_query(uri.query, params_for(message))
+        uri.query = merged_query unless merged_query.nil? || merged_query.empty?
+        uri
+      end
+
+      def params_for(message)
+        default_params = @params || {}
+        message_params = message.metadata[:params] || {}
+        return nil if default_params.empty? && message_params.empty?
+
+        default_params.merge(message_params)
+      end
+
+      def build_request(message, uri)
+        request = request_class_for(method_for(message)).new(uri.request_uri)
+        resolved_headers(message).each { |key, value| request[key] = value }
+        apply_basic_auth(request, basic_auth_for(message))
+
+        return request unless BODY_METHODS.include?(method_for(message))
+
+        encoded_body = encode_body(message)
+        request.body = encoded_body unless encoded_body.nil?
+        request
+      end
+
+      def method_for(message)
+        (message.metadata[:method] || @method).to_sym
+      end
+
+      def resolved_headers(message)
+        headers = @headers.merge(message.metadata[:headers] || {})
+        return headers unless content_type_header_needed?(headers)
+
+        inferred = inferred_content_type(message)
+        inferred ? headers.merge("Content-Type" => inferred) : headers
+      end
+
+      def content_type_header_needed?(headers)
+        headers.keys.none? { |key| key.downcase == "content-type" }
+      end
+
+      def inferred_content_type(message)
+        case message.content_type
+        when :json
+          "application/json"
+        when :form
+          "application/x-www-form-urlencoded"
+        when :html
+          "text/html"
+        when :binary
+          "application/octet-stream"
+        when :text
+          message.body.is_a?(Hash) || message.body.is_a?(Array) ? "application/json" : "text/plain"
+        else
+          nil
+        end
+      end
+
+      def encode_body(message)
+        body = message.body
+        return nil if body.nil?
+
+        case content_type_for(message)
+        when "application/x-www-form-urlencoded"
+          raise ArgumentError, "Form webhook body must be a Hash" unless body.is_a?(Hash)
+
+          URI.encode_www_form(body)
+        when "application/json"
+          body.is_a?(String) ? body : JSON.generate(body)
+        else
+          body.respond_to?(:read) ? body.read : body.to_s
+        end
+      end
+
+      def content_type_for(message)
+        explicit = resolved_headers(message).find { |key, _| key.downcase == "content-type" }
+        explicit ? explicit.last : inferred_content_type(message)
+      end
+
+      def basic_auth_for(message)
+        message.metadata[:basic_auth] || @basic_auth
+      end
+
+      def apply_basic_auth(request, credentials)
+        return unless credentials
+
+        username, password = case credentials
+                             when Array then credentials
+                             when Hash then [credentials[:username] || credentials["username"],
+                                             credentials[:password] || credentials["password"]]
+                             else
+                               raise ArgumentError, "basic_auth must be an Array or Hash"
+                             end
+        request.basic_auth(username.to_s, password.to_s)
+      end
+
+      def perform_request(uri, request)
+        http = Net::HTTP.new(uri.host, uri.port)
+        http.use_ssl = uri.scheme == "https"
+        http.open_timeout = @open_timeout
+        http.read_timeout = @read_timeout
+        http.request(request)
+      end
+
+      def request_class_for(method)
+        case method
+        when :get then Net::HTTP::Get
+        when :post then Net::HTTP::Post
+        when :put then Net::HTTP::Put
+        when :patch then Net::HTTP::Patch
+        when :delete then Net::HTTP::Delete
+        else
+          raise ArgumentError, "Unsupported webhook HTTP method: #{method.inspect}"
+        end
+      end
+
+      def merge_query(existing_query, extra_params)
+        return existing_query if extra_params.nil? || extra_params.empty?
+
+        existing = existing_query ? URI.decode_www_form(existing_query) : []
+        extra = URI.encode_www_form(extra_params).split("&").map { |pair| pair.split("=", 2) }
+        URI.encode_www_form(existing + extra)
+      end
+
+      def parse_response_body(body)
+        JSON.parse(body.to_s)
+      rescue JSON::ParserError
+        body.to_s
+      end
+
+      def delivery_status_for(response)
+        return :queued if response.code.to_i == 202
+
+        :delivered
+      end
+    end
+  end
+end

data/packages/igniter-sdk/lib/igniter/sdk/channels.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require "igniter/core/errors"
+require "igniter/core/effect"
+
+module Igniter
+  module Channels
+    class Error < Igniter::Error; end
+    class DeliveryError < Error; end
+  end
+end
+
+require_relative "channels/message"
+require_relative "channels/delivery_result"
+require_relative "channels/base"
+require_relative "channels/telegram"
+require_relative "channels/webhook"

data/packages/igniter-sdk/lib/igniter/sdk/data/store.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Data
+    class Store
+      def put(collection:, key:, value:)
+        raise NotImplementedError, "#{self.class}#put not implemented"
+      end
+
+      def get(collection:, key:)
+        raise NotImplementedError, "#{self.class}#get not implemented"
+      end
+
+      def delete(collection:, key:)
+        raise NotImplementedError, "#{self.class}#delete not implemented"
+      end
+
+      def all(collection:)
+        raise NotImplementedError, "#{self.class}#all not implemented"
+      end
+
+      def keys(collection:)
+        raise NotImplementedError, "#{self.class}#keys not implemented"
+      end
+
+      def clear(collection: nil)
+        raise NotImplementedError, "#{self.class}#clear not implemented"
+      end
+    end
+  end
+end

data/packages/igniter-sdk/lib/igniter/sdk/data/stores/file.rb

@@ -0,0 +1,113 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Igniter
+  module Data
+    module Stores
+      class File < Store
+        def initialize(path:) # rubocop:disable Lint/MissingSuper
+          @path = path.to_s
+          raise ConfigurationError, "File data store path cannot be blank" if @path.empty?
+
+          prepare_path!
+        end
+
+        def put(collection:, key:, value:)
+          mutate do |data|
+            data[collection.to_s] ||= {}
+            data[collection.to_s][key.to_s] = deep_copy(value)
+            deep_copy(value)
+          end
+        end
+
+        def get(collection:, key:)
+          read_data do |data|
+            value = data.fetch(collection.to_s, {}).fetch(key.to_s, nil)
+            value.nil? ? nil : deep_copy(value)
+          end
+        end
+
+        def delete(collection:, key:)
+          mutate do |data|
+            collection_data = data.fetch(collection.to_s, {})
+            value = collection_data.delete(key.to_s)
+            data.delete(collection.to_s) if collection_data.empty?
+            value.nil? ? nil : deep_copy(value)
+          end
+        end
+
+        def all(collection:)
+          read_data do |data|
+            data.fetch(collection.to_s, {}).each_with_object({}) do |(key, value), memo|
+              memo[key] = deep_copy(value)
+            end
+          end
+        end
+
+        def keys(collection:)
+          read_data do |data|
+            data.fetch(collection.to_s, {}).keys.sort
+          end
+        end
+
+        def clear(collection: nil)
+          mutate do |data|
+            if collection
+              data.delete(collection.to_s)
+            else
+              data.clear
+            end
+
+            nil
+          end
+        end
+
+        private
+
+        def mutate
+          ::File.open(@path, ::File::RDWR | ::File::CREAT, 0o644) do |file|
+            file.flock(::File::LOCK_EX)
+            data = parse(file.read)
+            result = yield(data)
+            file.rewind
+            file.truncate(0)
+            file.write(JSON.generate(data))
+            file.flush
+            result
+          ensure
+            file.flock(::File::LOCK_UN) rescue nil # rubocop:disable Style/RescueModifier
+          end
+        end
+
+        def read_data
+          ::File.open(@path, ::File::RDWR | ::File::CREAT, 0o644) do |file|
+            file.flock(::File::LOCK_SH)
+            yield(parse(file.read))
+          ensure
+            file.flock(::File::LOCK_UN) rescue nil # rubocop:disable Style/RescueModifier
+          end
+        end
+
+        def parse(payload)
+          content = payload.to_s.strip
+          return {} if content.empty?
+
+          JSON.parse(content)
+        rescue JSON::ParserError
+          {}
+        end
+
+        def prepare_path!
+          FileUtils.mkdir_p(::File.dirname(@path))
+          ::File.write(@path, "{}") unless ::File.exist?(@path)
+        end
+
+        def deep_copy(value)
+          JSON.parse(JSON.generate(value))
+        end
+      end
+    end
+  end
+end

data/packages/igniter-sdk/lib/igniter/sdk/data/stores/in_memory.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Igniter
+  module Data
+    module Stores
+      class InMemory < Store
+        def initialize # rubocop:disable Lint/MissingSuper
+          @collections = Hash.new { |hash, key| hash[key] = {} }
+          @mutex = Mutex.new
+        end
+
+        def put(collection:, key:, value:)
+          @mutex.synchronize do
+            @collections[collection.to_s][key.to_s] = deep_copy(value)
+            deep_copy(value)
+          end
+        end
+
+        def get(collection:, key:)
+          @mutex.synchronize do
+            value = @collections[collection.to_s][key.to_s]
+            value.nil? ? nil : deep_copy(value)
+          end
+        end
+
+        def delete(collection:, key:)
+          @mutex.synchronize do
+            value = @collections[collection.to_s].delete(key.to_s)
+            value.nil? ? nil : deep_copy(value)
+          end
+        end
+
+        def all(collection:)
+          @mutex.synchronize do
+            @collections[collection.to_s].each_with_object({}) do |(key, value), memo|
+              memo[key] = deep_copy(value)
+            end
+          end
+        end
+
+        def keys(collection:)
+          @mutex.synchronize { @collections[collection.to_s].keys.sort }
+        end
+
+        def clear(collection: nil)
+          @mutex.synchronize do
+            if collection
+              @collections.delete(collection.to_s)
+            else
+              @collections = Hash.new { |hash, key| hash[key] = {} }
+            end
+          end
+        end
+
+        private
+
+        def deep_copy(value)
+          Marshal.load(Marshal.dump(value))
+        end
+      end
+    end
+  end
+end

data/packages/igniter-sdk/lib/igniter/sdk/data/stores/sqlite.rb

@@ -0,0 +1,144 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "json"
+
+module Igniter
+  module Data
+    module Stores
+      class SQLite < Store
+        attr_reader :path
+
+        def initialize(path:) # rubocop:disable Lint/MissingSuper
+          require "sqlite3"
+        rescue LoadError
+          raise ConfigurationError,
+                "`igniter` now ships with a required `sqlite3` dependency. " \
+                "If it is missing in this environment, run bundle install or reinstall the gem."
+        else
+          @path = path
+          prepare_path!(path)
+          @mutex = Mutex.new
+          @db = ::SQLite3::Database.new(path)
+          @db.results_as_hash = true
+          @db.busy_timeout = 1000 if @db.respond_to?(:busy_timeout=)
+          create_schema!
+        end
+
+        def put(collection:, key:, value:)
+          @mutex.synchronize do
+            with_db do |db|
+              db.execute(
+                "INSERT OR REPLACE INTO data_records (collection, key, value_json, updated_at) VALUES (?, ?, ?, ?)",
+                [collection.to_s, key.to_s, JSON.generate(value), Time.now.to_i]
+              )
+            end
+            decode(value)
+          end
+        end
+
+        def get(collection:, key:)
+          @mutex.synchronize do
+            row = with_db do |db|
+              db.get_first_row(
+                "SELECT value_json FROM data_records WHERE collection = ? AND key = ?",
+                [collection.to_s, key.to_s]
+              )
+            end
+            row ? decode_json(row["value_json"]) : nil
+          end
+        end
+
+        def delete(collection:, key:)
+          @mutex.synchronize do
+            row = with_db do |db|
+              existing = db.get_first_row(
+                "SELECT value_json FROM data_records WHERE collection = ? AND key = ?",
+                [collection.to_s, key.to_s]
+              )
+              db.execute(
+                "DELETE FROM data_records WHERE collection = ? AND key = ?",
+                [collection.to_s, key.to_s]
+              )
+              existing
+            end
+            row ? decode_json(row["value_json"]) : nil
+          end
+        end
+
+        def all(collection:)
+          @mutex.synchronize do
+            rows = with_db do |db|
+              db.execute(
+                "SELECT key, value_json FROM data_records WHERE collection = ? ORDER BY key ASC",
+                [collection.to_s]
+              )
+            end
+            rows.each_with_object({}) do |row, memo|
+              memo[row["key"]] = decode_json(row["value_json"])
+            end
+          end
+        end
+
+        def keys(collection:)
+          @mutex.synchronize do
+            with_db do |db|
+              db.execute(
+                "SELECT key FROM data_records WHERE collection = ? ORDER BY key ASC",
+                [collection.to_s]
+              ).map { |row| row["key"] }
+            end
+          end
+        end
+
+        def clear(collection: nil)
+          @mutex.synchronize do
+            with_db do |db|
+              if collection
+                db.execute("DELETE FROM data_records WHERE collection = ?", [collection.to_s])
+              else
+                db.execute("DELETE FROM data_records")
+              end
+            end
+          end
+        end
+
+        private
+
+        def create_schema!
+          with_db do |db|
+            db.execute_batch(<<~SQL)
+              CREATE TABLE IF NOT EXISTS data_records (
+                collection TEXT NOT NULL,
+                key TEXT NOT NULL,
+                value_json TEXT NOT NULL,
+                updated_at INTEGER NOT NULL,
+                PRIMARY KEY (collection, key)
+              );
+              CREATE INDEX IF NOT EXISTS idx_data_records_collection_updated_at
+                ON data_records(collection, updated_at);
+            SQL
+          end
+        end
+
+        def decode_json(payload)
+          JSON.parse(payload)
+        end
+
+        def decode(value)
+          decode_json(JSON.generate(value))
+        end
+
+        def prepare_path!(path)
+          return if path.to_s.empty? || path == ":memory:"
+
+          FileUtils.mkdir_p(::File.dirname(path))
+        end
+
+        def with_db
+          yield @db
+        end
+      end
+    end
+  end
+end

data/packages/igniter-sdk/lib/igniter/sdk/data.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "igniter/core/errors"
+
+module Igniter
+  module Data
+    ConfigurationError = Class.new(Igniter::Error)
+  end
+end
+
+require_relative "data/store"
+require_relative "data/stores/file"
+require_relative "data/stores/in_memory"
+require_relative "data/stores/sqlite"
+
+module Igniter
+  module Data
+    class << self
+      def default_store
+        @default_store ||= Stores::InMemory.new
+      end
+
+      attr_writer :default_store
+
+      def configure
+        yield self
+      end
+
+      def reset!
+        @default_store = nil
+      end
+    end
+  end
+end