flow_chat 0.8.1 → 0.9.0

data/lib/flow_chat/base_processor.rb

@@ -1,145 +0,0 @@
-require "middleware"
-
-module FlowChat
-  class BaseProcessor
-    include FlowChat::Instrumentation
-
-    attr_reader :middleware
-
-    def initialize(controller, enable_simulator: nil)
-      FlowChat.logger.debug { "BaseProcessor: Initializing processor for controller #{controller.class.name}" }
-
-      @context = FlowChat::Context.new
-      @context["controller"] = controller
-      @context["enable_simulator"] = enable_simulator.nil? ? (defined?(Rails) && Rails.env.local?) : enable_simulator
-      @middleware = ::Middleware::Builder.new(name: middleware_name)
-      @session_options = FlowChat::Config.session
-
-      FlowChat.logger.debug { "BaseProcessor: Simulator mode #{@context["enable_simulator"] ? "enabled" : "disabled"}" }
-
-      yield self if block_given?
-
-      FlowChat.logger.debug { "BaseProcessor: Initialized #{self.class.name} successfully" }
-    end
-
-    def use_gateway(gateway_class, *args)
-      FlowChat.logger.debug { "BaseProcessor: Configuring gateway #{gateway_class.name} with args: #{args.inspect}" }
-      @gateway_class = gateway_class
-      @gateway_args = args
-      self
-    end
-
-    def use_session_store(session_store)
-      raise "Session store must be a class" unless session_store.is_a?(Class)
-      FlowChat.logger.debug { "BaseProcessor: Configuring session store #{session_store.name}" }
-      @context["session.store"] = session_store
-      self
-    end
-
-    def use_session_config(boundaries: nil, hash_phone_numbers: nil, identifier: nil)
-      FlowChat.logger.debug { "BaseProcessor: Configuring session config: boundaries=#{boundaries.inspect}, hash_phone_numbers=#{hash_phone_numbers}, identifier=#{identifier}" }
-      
-      # Update the session options directly
-      @session_options = @session_options.dup
-      @session_options.boundaries = Array(boundaries) if boundaries
-      @session_options.hash_phone_numbers = hash_phone_numbers if hash_phone_numbers
-      @session_options.identifier = identifier if identifier
-      
-      self
-    end
-
-    def use_middleware(middleware)
-      raise "Middleware must be a class" unless middleware.is_a?(Class)
-      FlowChat.logger.debug { "BaseProcessor: Adding middleware #{middleware.name}" }
-      @middleware.use middleware
-      self
-    end
-
-    def use_cross_platform_sessions
-      FlowChat.logger.debug { "BaseProcessor: Enabling cross-platform sessions via session configuration" }
-      use_session_config(
-        boundaries: [:flow]
-      )
-      self
-    end
-
-    def use_url_isolation
-      FlowChat.logger.debug { "BaseProcessor: Enabling URL-based session isolation" }
-      current_boundaries = @session_options.boundaries.dup
-      current_boundaries << :url unless current_boundaries.include?(:url)
-      use_session_config(boundaries: current_boundaries)
-    end
-
-    def run(flow_class, action)
-      # Instrument flow execution (this will log via LogSubscriber)
-      instrument(Events::FLOW_EXECUTION_START, {
-        flow_name: flow_class.name.underscore,
-        action: action.to_s,
-        processor_type: self.class.name
-      })
-
-      @context["flow.name"] = flow_class.name.underscore
-      @context["flow.class"] = flow_class
-      @context["flow.action"] = action
-
-      FlowChat.logger.debug { "BaseProcessor: Context prepared for flow #{flow_class.name}" }
-
-      stack = build_middleware_stack
-      yield stack if block_given?
-
-      FlowChat.logger.debug { "BaseProcessor: Executing middleware stack for #{flow_class.name}##{action}" }
-
-      # Instrument flow execution with timing (this will log completion via LogSubscriber)
-      instrument(Events::FLOW_EXECUTION_END, {
-        flow_name: flow_class.name.underscore,
-        action: action.to_s,
-        processor_type: self.class.name
-      }) do
-        stack.call(@context)
-      end
-    rescue => error
-      FlowChat.logger.error { "BaseProcessor: Flow execution failed - #{flow_class.name}##{action}, Error: #{error.class.name}: #{error.message}" }
-      FlowChat.logger.debug { "BaseProcessor: Stack trace: #{error.backtrace.join("\n")}" }
-
-      # Instrument flow execution error (this will log error via LogSubscriber)
-      instrument(Events::FLOW_EXECUTION_ERROR, {
-        flow_name: flow_class.name.underscore,
-        action: action.to_s,
-        processor_type: self.class.name,
-        error_class: error.class.name,
-        error_message: error.message,
-        backtrace: error.backtrace&.first(10)
-      })
-
-      raise
-    end
-
-    protected
-
-    # Subclasses should override these methods
-    def middleware_name
-      raise NotImplementedError, "Subclasses must implement middleware_name"
-    end
-
-    def build_middleware_stack
-      raise NotImplementedError, "Subclasses must implement build_middleware_stack"
-    end
-
-    # Helper method for building stacks
-    def create_middleware_stack(name)
-      raise ArgumentError, "Gateway is required. Call use_gateway(gateway_class, *args) before running." unless @gateway_class
-
-      ::Middleware::Builder.new(name: name) do |b|
-        b.use @gateway_class, *@gateway_args
-        b.use FlowChat::Session::Middleware, @session_options
-        configure_middleware_stack(b)
-      end.inject_logger(FlowChat.logger)
-    end
-
-    def configure_middleware_stack(builder)
-      raise NotImplementedError, "Subclasses must implement configure_middleware_stack"
-    end
-
-    attr_reader :context
-  end
-end

data/lib/flow_chat/session/rails_session_store.rb

@@ -1,68 +0,0 @@
-module FlowChat
-  module Session
-    class RailsSessionStore
-      include FlowChat::Instrumentation
-
-      # Make context available for instrumentation enrichment
-      attr_reader :context
-
-      def initialize(context)
-        @context = context
-        @session_id = context["session.id"]
-        @session_store = context.controller.session
-        @session_data = (session_store[session_id] || {}).with_indifferent_access
-
-        FlowChat.logger.debug { "RailsSessionStore: Initialized Rails session store for session #{session_id}" }
-        FlowChat.logger.debug { "RailsSessionStore: Loaded session data with #{session_data.keys.size} keys" }
-      end
-
-      def get(key)
-        value = session_data[key]
-
-        # Use instrumentation for data get
-        instrument(Events::SESSION_DATA_GET, {
-          session_id: session_id,
-          key: key.to_s,
-          value: value
-        })
-
-        value
-      end
-
-      def set(key, value)
-        FlowChat.logger.debug { "RailsSessionStore: Setting key '#{key}' = #{value.inspect} in session #{session_id}" }
-
-        session_data[key] = value
-        session_store[session_id] = session_data
-
-        # Use instrumentation for data set
-        instrument(Events::SESSION_DATA_SET, {
-          session_id: session_id,
-          key: key.to_s
-        })
-
-        FlowChat.logger.debug { "RailsSessionStore: Session data saved to Rails session store" }
-        value
-      end
-
-      def delete(key)
-        FlowChat.logger.debug { "RailsSessionStore: Deleting key '#{key}' from session #{session_id}" }
-        set key, nil
-      end
-
-      def destroy
-        # Use instrumentation for session destruction
-        instrument(Events::SESSION_DESTROYED, {
-          session_id: session_id,
-          gateway: "rails" # Rails doesn't have a specific gateway context
-        })
-
-        session_store[session_id] = nil
-      end
-
-      private
-
-      attr_reader :session_id, :session_store, :session_data
-    end
-  end
-end

data/lib/flow_chat/ussd/app.rb

@@ -1,6 +0,0 @@
-module FlowChat
-  module Ussd
-    class App < FlowChat::BaseApp
-    end
-  end
-end

data/lib/flow_chat/ussd/gateway/nsano.rb

@@ -1,98 +0,0 @@
-require "phonelib"
-
-module FlowChat
-  module Ussd
-    module Gateway
-      class Nsano
-        include FlowChat::Instrumentation
-
-        attr_reader :context
-
-        def initialize(app)
-          @app = app
-        end
-
-        def call(context)
-          @context = context
-          controller = context["controller"]
-          controller.request
-
-          # Add timestamp for all requests
-          context["request.timestamp"] = Time.current.iso8601
-
-          # Set a basic message_id (can be enhanced based on actual Nsano implementation)
-          context["request.message_id"] = SecureRandom.uuid
-          context["request.platform"] = :ussd
-
-          # TODO: Implement Nsano-specific parameter parsing
-          # For now, add basic instrumentation structure for when this is implemented
-
-          # Placeholder instrumentation - indicates Nsano implementation is needed
-          instrument(Events::MESSAGE_RECEIVED, {
-            from: "TODO",  # Would be parsed from Nsano params
-            message: "TODO",  # Would be actual user input
-            session_id: "TODO",  # Would be Nsano session ID
-            gateway: :nsano,
-            platform: :ussd,
-            timestamp: context["request.timestamp"]
-          })
-
-          # Process request with placeholder app call
-          _, _, _, _ = @app.call(context) if @app
-
-          # Placeholder response instrumentation
-          instrument(Events::MESSAGE_SENT, {
-            to: "TODO",  # Would be actual phone number
-            session_id: "TODO",  # Would be Nsano session ID
-            message: "TODO",  # Would be actual response message
-            message_type: "prompt",  # Would depend on actual response type
-            gateway: :nsano,
-            platform: :ussd,
-            content_length: 0,  # Would be actual content length
-            timestamp: context["request.timestamp"]
-          })
-
-          # input = context["rack.input"].read
-          # context["rack.input"].rewind
-          # if input.present?
-          #   params = JSON.parse input
-          #   if params["network"].present? && params["UserSessionID"].present?
-          #     request_id = "nsano::request_id::#{params["UserSessionID"]}"
-          #     context["ussd.request"] = {
-          #       gateway: :nsano,
-          #       network: params["network"].to_sym,
-          #       msisdn: Phonelib.parse(params["msisdn"]).e164,
-          #       type: Config.cache&.read(request_id).present? ? :response : :initial,
-          #       input: params["msg"].presence,
-          #       network: params["network"]
-          #     }
-          #   end
-          # end
-
-          # status, headers, response = @app.call(context)
-
-          # if context["ussd.response"].present? && context["ussd.request"][:gateway] == :nsano
-          #   if context["ussd.response"][:type] == :terminal
-          #     Config.cache&.write(request_id, nil)
-          #   else
-          #     Config.cache&.write(request_id, 1)
-          #   end
-
-          #   status = 200
-          #   response =
-          #     {
-          #       USSDResp: {
-          #         action: (context["ussd.response"][:type] == :terminal) ? :prompt : :input,
-          #         menus: "",
-          #         title: context["ussd.response"][:body]
-          #       }
-          #     }.to_json
-          #   headers = headers.merge({"Content-Type" => "application/json", "Content-Length" => response.bytesize.to_s})
-          #   response = [response]
-          # end
-          # [status, headers, response]
-        end
-      end
-    end
-  end
-end

data/lib/flow_chat/ussd/middleware/executor.rb

@@ -1,24 +0,0 @@
-require_relative "../../base_executor"
-
-module FlowChat
-  module Ussd
-    module Middleware
-      class Executor < FlowChat::BaseExecutor
-        protected
-
-        def platform_name
-          "USSD"
-        end
-
-        def log_prefix
-          "Ussd::Executor"
-        end
-
-        def build_platform_app(context)
-          FlowChat.logger.debug { "#{log_prefix}: Building USSD app instance" }
-          FlowChat::Ussd::App.new(context)
-        end
-      end
-    end
-  end
-end

data/lib/flow_chat/ussd/processor.rb

@@ -1,39 +0,0 @@
-module FlowChat
-  module Ussd
-    class Processor < FlowChat::BaseProcessor
-      def use_durable_sessions(cross_gateway: false)
-        FlowChat.logger.debug { "Ussd::Processor: Enabling durable sessions via session configuration" }
-        use_session_config(
-          identifier: :msisdn  # Use MSISDN for durable sessions
-        )
-      end
-
-      protected
-
-      def middleware_name
-        "ussd.middleware"
-      end
-
-      def build_middleware_stack
-        FlowChat.logger.debug { "Ussd::Processor: Building USSD middleware stack" }
-        create_middleware_stack("ussd")
-      end
-
-      def configure_middleware_stack(builder)
-        FlowChat.logger.debug { "Ussd::Processor: Configuring USSD middleware stack" }
-
-        builder.use FlowChat::Ussd::Middleware::Pagination
-        FlowChat.logger.debug { "Ussd::Processor: Added Ussd::Middleware::Pagination" }
-
-        builder.use middleware
-        FlowChat.logger.debug { "Ussd::Processor: Added custom middleware" }
-
-        builder.use FlowChat::Ussd::Middleware::ChoiceMapper
-        FlowChat.logger.debug { "Ussd::Processor: Added Ussd::Middleware::ChoiceMapper" }
-
-        builder.use FlowChat::Ussd::Middleware::Executor
-        FlowChat.logger.debug { "Ussd::Processor: Added Ussd::Middleware::Executor" }
-      end
-    end
-  end
-end

data/lib/flow_chat/whatsapp/app.rb

@@ -1,29 +0,0 @@
-module FlowChat
-  module Whatsapp
-    class App < FlowChat::BaseApp
-      def contact_name
-        context["request.contact_name"]
-      end
-
-      def location
-        context["request.location"]
-      end
-
-      def media
-        context["request.media"]
-      end
-
-      protected
-
-      # WhatsApp has special startup logic and supports media
-      def prepare_user_input
-        user_input = input
-        if session.get("$started_at$").nil?
-          session.set("$started_at$", Time.current.iso8601)
-          user_input = nil
-        end
-        user_input
-      end
-    end
-  end
-end

data/lib/flow_chat/whatsapp/middleware/executor.rb

@@ -1,24 +0,0 @@
-require_relative "../../base_executor"
-
-module FlowChat
-  module Whatsapp
-    module Middleware
-      class Executor < FlowChat::BaseExecutor
-        protected
-
-        def platform_name
-          "WhatsApp"
-        end
-
-        def log_prefix
-          "Whatsapp::Executor"
-        end
-
-        def build_platform_app(context)
-          FlowChat.logger.debug { "#{log_prefix}: Building WhatsApp app instance" }
-          FlowChat::Whatsapp::App.new(context)
-        end
-      end
-    end
-  end
-end

data/lib/flow_chat/whatsapp/processor.rb

@@ -1,32 +0,0 @@
-module FlowChat
-  module Whatsapp
-    class Processor < FlowChat::BaseProcessor
-      def use_whatsapp_config(config)
-        FlowChat.logger.debug { "Whatsapp::Processor: Configuring WhatsApp config: #{config.class.name}" }
-        @whatsapp_config = config
-        self
-      end
-
-      protected
-
-      def middleware_name
-        "whatsapp.middleware"
-      end
-
-      def build_middleware_stack
-        FlowChat.logger.debug { "Whatsapp::Processor: Building WhatsApp middleware stack" }
-        create_middleware_stack("whatsapp")
-      end
-
-      def configure_middleware_stack(builder)
-        FlowChat.logger.debug { "Whatsapp::Processor: Configuring WhatsApp middleware stack" }
-
-        builder.use middleware
-        FlowChat.logger.debug { "Whatsapp::Processor: Added custom middleware" }
-
-        builder.use FlowChat::Whatsapp::Middleware::Executor
-        FlowChat.logger.debug { "Whatsapp::Processor: Added Whatsapp::Middleware::Executor" }
-      end
-    end
-  end
-end

data/lib/flow_chat/whatsapp/send_job_support.rb

@@ -1,79 +0,0 @@
-module FlowChat
-  module Whatsapp
-    # Module to be included in background jobs for WhatsApp response delivery
-    # Only handles sending responses, not processing flows
-    module SendJobSupport
-      extend ActiveSupport::Concern
-
-      included do
-        # Set up job configuration
-        queue_as :default
-        retry_on StandardError, wait: :exponentially_longer, attempts: 3
-      end
-
-      # Main job execution method for sending responses
-      def perform_whatsapp_send(send_data)
-        config = resolve_whatsapp_config(send_data)
-        client = FlowChat::Whatsapp::Client.new(config)
-
-        result = client.send_message(send_data[:msisdn], send_data[:response])
-
-        if result
-          Rails.logger.info "WhatsApp message sent successfully: #{result["messages"]&.first&.dig("id")}"
-          on_whatsapp_send_success(send_data, result)
-        else
-          Rails.logger.error "Failed to send WhatsApp message to #{send_data[:msisdn]}"
-          raise "WhatsApp API call failed"
-        end
-      rescue => e
-        on_whatsapp_send_error(e, send_data)
-        handle_whatsapp_send_error(e, send_data, config)
-      end
-
-      private
-
-      # Resolve WhatsApp configuration by name or fallback
-      def resolve_whatsapp_config(send_data)
-        # Try to resolve by name first (preferred method)
-        if send_data[:config_name] && FlowChat::Whatsapp::Configuration.exists?(send_data[:config_name])
-          return FlowChat::Whatsapp::Configuration.get(send_data[:config_name])
-        end
-
-        # Final fallback to default configuration
-        FlowChat::Whatsapp::Configuration.from_credentials
-      end
-
-      # Handle errors with user notification
-      def handle_whatsapp_send_error(error, send_data, config = nil)
-        Rails.logger.error "WhatsApp send job error: #{error.message}"
-        Rails.logger.error error.backtrace&.join("\n") if error.backtrace
-
-        # Try to send error message to user if we have config
-        if config
-          begin
-            client = FlowChat::Whatsapp::Client.new(config)
-            client.send_text(
-              send_data[:msisdn],
-              "⚠️ We're experiencing technical difficulties. Please try again in a few minutes."
-            )
-          rescue => send_error
-            Rails.logger.error "Failed to send error message: #{send_error.message}"
-          end
-        end
-
-        # Re-raise for job retry logic
-        raise error
-      end
-
-      # Override this method in your job for custom behavior
-      def on_whatsapp_send_success(send_data, result)
-        # Optional callback for successful message sending
-      end
-
-      # Override this method in your job for custom error handling
-      def on_whatsapp_send_error(error, send_data)
-        # Optional callback for error handling
-      end
-    end
-  end
-end