command_tower 0.3.1 → 0.10.0

data/app/workflows/command_tower/workflows/me/update_name_workflow.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Me
+      class UpdateNameWorkflow < CommandTower::Workflows::ApplicationWorkflow
+        retry_strategy :none
+
+        def call(current_user:, first_name:, last_name:, auth_context: nil)
+          update_result = CommandTower::Services::Me::UpdateName.call(
+            user: current_user,
+            first_name:,
+            last_name:
+          )
+
+          unless update_result.success?
+            error = update_result.errors.first
+            return failure(
+              errors: update_result.errors,
+              http_status: CommandTower::Workflows::Me::ErrorStatus.http_status_for(error)
+            )
+          end
+
+          user = update_result.data[:user].reload
+          capabilities = CommandTower::Services::Me::Capabilities.project(user)
+          payload = CommandTower::Serializers::Me::AccountSerializer.serialize(
+            user,
+            capabilities: capabilities
+          )
+
+          success(
+            payload: payload,
+            http_status: :ok,
+            response_effects: expire_header_effects(auth_context)
+          )
+        end
+
+        private
+
+        def expire_header_effects(auth_context)
+          return if auth_context.nil?
+
+          { set_expire_header: auth_context.token_expires_at }
+        end
+      end
+    end
+  end
+end

data/app/workflows/command_tower/workflows/me/update_phone_workflow.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Me
+      class UpdatePhoneWorkflow < CommandTower::Workflows::ApplicationWorkflow
+        retry_strategy :none
+
+        def call(current_user:, phone_number:, auth_context: nil)
+          unless CommandTower::Services::Me::SmsProductGate.enabled?
+            error = CommandTower::Errors::Account::SmsCapabilityUnavailableError.new
+            return failure(
+              errors: [error],
+              http_status: CommandTower::Workflows::Me::ErrorMapping.http_status_for(error)
+            )
+          end
+
+          update_result = CommandTower::Services::Account::UpdatePhone.call(
+            user: current_user,
+            phone_number:
+          )
+
+          unless update_result.success?
+            error = update_result.errors.first
+            return failure(
+              errors: update_result.errors,
+              http_status: CommandTower::Workflows::Me::ErrorMapping.http_status_for(error)
+            )
+          end
+
+          user = update_result.data[:user].reload
+          capabilities = CommandTower::Services::Me::Capabilities.project(user)
+          payload = CommandTower::Serializers::Me::AccountSerializer.serialize(
+            user,
+            capabilities: capabilities
+          )
+
+          success(
+            payload: payload,
+            http_status: :ok,
+            response_effects: expire_header_effects(auth_context)
+          )
+        end
+
+        private
+
+        def expire_header_effects(auth_context)
+          return if auth_context.nil?
+
+          { set_expire_header: auth_context.token_expires_at }
+        end
+      end
+    end
+  end
+end

data/app/workflows/command_tower/workflows/messaging/communications/produce_recipient_workflow.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Messaging
+      module Communications
+        # Thin job entry for async ProduceMany units. Reloads User by id then Produce.
+        class ProduceRecipientWorkflow < CommandTower::Workflows::ApplicationWorkflow
+          retry_strategy :none
+
+          def call(
+            user_id:,
+            notification_type_key:,
+            campaign_identity:,
+            title:,
+            body:,
+            platform_enabled_channels:,
+            metadata: nil
+          )
+            user = User.find_by(id: user_id)
+            unless user
+              return failure(
+                errors: [CommandTower::Errors::NotFoundError.new],
+                http_status: :not_found,
+                meta: { propagate_to_job: false }
+              )
+            end
+
+            result = CommandTower::Services::Messaging::Communications::Produce.call(
+              user:,
+              notification_type_key:,
+              host_event_identity: "#{campaign_identity}/#{user.id}",
+              title:,
+              body:,
+              metadata:,
+              platform_enabled_channels:,
+            )
+
+            unless result.success?
+              return failure(
+                errors: result.errors,
+                http_status: CommandTower::Workflows::Messaging::ErrorMapping.http_status_for(result.errors.first),
+                meta: { propagate_to_job: false }
+              )
+            end
+
+            success(
+              payload: {
+                "communicationId" => result.data[:communication_id],
+                "inboxItemId" => result.data[:inbox_item_id],
+                "userId" => user.id,
+              },
+              http_status: :ok
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/workflows/command_tower/workflows/messaging/error_mapping.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Messaging
+      module ErrorMapping
+        module_function
+
+        def http_status_for(error)
+          case error
+          when CommandTower::Errors::ValidationError,
+               CommandTower::Errors::Messaging::RecipientUnresolvedError,
+               CommandTower::Errors::Messaging::AcceptRejectedError
+            :unprocessable_entity
+          when CommandTower::Errors::Messaging::IdempotencyConflictError
+            :conflict
+          when CommandTower::Errors::NotFoundError
+            :not_found
+          else
+            :internal_server_error
+          end
+        end
+      end
+    end
+  end
+end

data/app/workflows/command_tower/workflows/messaging/execution/deliver_workflow.rb

@@ -0,0 +1,234 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Messaging
+      module Execution
+        # Job-entry orchestration for a single channel delivery attempt.
+        class DeliverWorkflow < CommandTower::Workflows::ApplicationWorkflow
+          retry_strategy :none
+
+          def call(channel_delivery_id:, executor: nil)
+            delivery = load_delivery(channel_delivery_id)
+            if delivery.nil?
+              return success(payload: { outcome: :noop, reason: :missing }, http_status: :ok)
+            end
+
+            if delivery.execution_terminal?
+              return success(
+                payload: { outcome: :noop, reason: :terminal, channel_delivery_id: delivery.id },
+                http_status: :ok,
+              )
+            end
+
+            unless CommandTower::Messaging::Execution::Claim.call(delivery:)
+              return success(
+                payload: { outcome: :noop, reason: :claim_lost, channel_delivery_id: delivery.id },
+                http_status: :ok,
+              )
+            end
+
+            delivery.reload
+            ledger = CommandTower::Messaging::Execution::AttemptLedger.new
+            CommandTower::Messaging::Execution::OperationLogger.claimed(channel_delivery: delivery)
+            CommandTower::Messaging::Execution::OperationLogger.started(channel_delivery: delivery)
+
+            attempt = ledger.start(delivery:)
+            if attempt.nil?
+              return success(
+                payload: { outcome: :retryable, reason: :attempt_create_failed, channel_delivery_id: delivery.id },
+                http_status: :ok,
+              )
+            end
+
+            begin
+              communication = delivery.communication
+              readiness = CommandTower::Messaging::Execution::RevalidateReadiness.call(
+                delivery:,
+                attempt:,
+                communication:,
+              )
+              if readiness.is_a?(String)
+                ledger.finalize_terminal(delivery:, attempt:, error_code: readiness)
+                return success(
+                  payload: { outcome: :terminal, channel_delivery_id: delivery.id, error_code: readiness },
+                  http_status: :ok,
+                )
+              end
+
+              resolution = CommandTower::Messaging::Execution::ResolveRecipientAddress.call(
+                communication:,
+                channel_key: delivery.channel_key,
+                readiness_result: readiness,
+              )
+
+              if resolution[:error_code]
+                ledger.finalize_terminal(delivery:, attempt:, error_code: resolution[:error_code])
+                return success(
+                  payload: {
+                    outcome: :terminal,
+                    channel_delivery_id: delivery.id,
+                    error_code: resolution[:error_code],
+                  },
+                  http_status: :ok,
+                )
+              end
+
+              recipient_address = resolution[:address]
+
+              unless CommandTower::Messaging::Rendering::ChannelRenderer.supported_channel?(delivery.channel_key)
+                ledger.finalize_terminal(delivery:, attempt:, error_code: "adapter_unconfigured")
+                return success(
+                  payload: {
+                    outcome: :terminal,
+                    channel_delivery_id: delivery.id,
+                    error_code: "adapter_unconfigured",
+                  },
+                  http_status: :ok,
+                )
+              end
+
+              if blank_recipient?(recipient_address)
+                ledger.finalize_terminal(delivery:, attempt:, error_code: "recipient_missing")
+                return success(
+                  payload: {
+                    outcome: :terminal,
+                    channel_delivery_id: delivery.id,
+                    error_code: "recipient_missing",
+                  },
+                  http_status: :ok,
+                )
+              end
+
+              rendered = render_payload!(delivery, attempt, communication, recipient_address, ledger)
+              if rendered.nil?
+                return success(
+                  payload: { outcome: :terminal, channel_delivery_id: delivery.id, error_code: :render_failed },
+                  http_status: :ok,
+                )
+              end
+
+              request = CommandTower::Messaging::Execution::AdapterRequest.build(
+                channel_delivery_id: delivery.id,
+                communication_id: delivery.communication_id,
+                channel_key: delivery.channel_key,
+                attempt_id: attempt.id,
+                rendered:,
+              )
+              adapter = CommandTower::Messaging::Execution::SelectAdapter.call(delivery:, executor:)
+              CommandTower::Messaging::Execution::OperationLogger.adapter_started(
+                channel_delivery: delivery,
+                delivery_attempt: attempt,
+              )
+              result = adapter.call(request:)
+              unless result.is_a?(CommandTower::Messaging::Execution::AdapterResult)
+                ledger.finalize_unexpected(delivery:, attempt:, error_class: result.class.name)
+                return success(
+                  payload: { outcome: :retryable, channel_delivery_id: delivery.id },
+                  http_status: :ok,
+                )
+              end
+
+              log_adapter_outcome!(delivery, attempt, result)
+              ledger.finalize_from_adapter(delivery:, attempt:, result:)
+              delivery.reload
+              success(
+                payload: {
+                  outcome: outcome_for(result),
+                  channel_delivery_id: delivery.id,
+                  status: delivery.status,
+                },
+                http_status: :ok,
+              )
+            rescue StandardError => error
+              ledger.finalize_unexpected(delivery:, attempt:, error:)
+              success(
+                payload: { outcome: :retryable, channel_delivery_id: delivery.id },
+                http_status: :ok,
+              )
+            end
+          end
+
+          private
+
+          def load_delivery(channel_delivery_id)
+            CommandTower::Messaging::ChannelDelivery.includes(
+              communication: %i[user destination_plan],
+            ).find_by(id: channel_delivery_id)
+          end
+
+          def blank_recipient?(recipient_address)
+            recipient_address.nil? || recipient_address.to_s.strip.empty?
+          end
+
+          def render_payload!(delivery, attempt, communication, recipient_address, ledger)
+            CommandTower::Messaging::Execution::OperationLogger.render_started(
+              channel_delivery: delivery,
+              delivery_attempt: attempt,
+            )
+
+            rendered = CommandTower::Messaging::Rendering::ChannelRenderer.render(
+              communication:,
+              channel_key: delivery.channel_key,
+              recipient_address:,
+            )
+
+            CommandTower::Messaging::Execution::OperationLogger.render_succeeded(
+              channel_delivery: delivery,
+              delivery_attempt: attempt,
+            )
+            rendered
+          rescue CommandTower::Messaging::Rendering::RenderError => error
+            CommandTower::Messaging::Execution::OperationLogger.render_failed(
+              channel_delivery: delivery,
+              delivery_attempt: attempt,
+              error_code: error.code,
+              error_class: error.error_class,
+            )
+            ledger.finalize_terminal(delivery:, attempt:, error_code: error.code)
+            nil
+          rescue StandardError => error
+            CommandTower::Messaging::Execution::OperationLogger.render_failed(
+              channel_delivery: delivery,
+              delivery_attempt: attempt,
+              error_code: "render_failed",
+              error_class: error.class.name,
+            )
+            ledger.finalize_terminal(delivery:, attempt:, error_code: "render_failed")
+            nil
+          end
+
+          def log_adapter_outcome!(delivery, attempt, result)
+            if result.success?
+              CommandTower::Messaging::Execution::OperationLogger.adapter_accepted(
+                channel_delivery: delivery,
+                delivery_attempt: attempt,
+              )
+            elsif result.retryable_failure?
+              CommandTower::Messaging::Execution::OperationLogger.adapter_retryable(
+                channel_delivery: delivery,
+                delivery_attempt: attempt,
+                error_code: result.error_code,
+              )
+            else
+              CommandTower::Messaging::Execution::OperationLogger.adapter_terminal(
+                channel_delivery: delivery,
+                delivery_attempt: attempt,
+                error_code: result.error_code,
+              )
+            end
+          end
+
+          def outcome_for(result)
+            case result.outcome
+            when :success then :delivered
+            when :retryable_failure then :retryable
+            when :terminal_failure then :terminal
+            else result.outcome
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/app/workflows/command_tower/workflows/messaging/handoff/process_workflow.rb

@@ -0,0 +1,90 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Messaging
+      module Handoff
+        # Job-entry orchestration: advance accepted communications into execution scheduling.
+        class ProcessWorkflow < CommandTower::Workflows::ApplicationWorkflow
+          retry_strategy :scheduled_cadence
+
+          def call(communication_id:)
+            communication = load_communication(communication_id)
+            if communication.nil?
+              return success(
+                payload: { outcome: :noop, reason: :missing },
+                http_status: :ok,
+              )
+            end
+
+            if communication.handoff_terminal?
+              return success(
+                payload: { outcome: :noop, reason: :terminal, communication_id: communication.id },
+                http_status: :ok,
+              )
+            end
+
+            CommandTower::Messaging::Handoff::OperationLogger.started(communication:)
+
+            begin
+              communication = CommandTower::Messaging::Handoff::AdvanceCommunication.call(
+                communication:,
+              )
+              CommandTower::Messaging::Handoff::OperationLogger.succeeded(communication:)
+              schedule_execution!(communication)
+              success(
+                payload: {
+                  outcome: :advanced,
+                  communication_id: communication.id,
+                  execution_handoff_status: communication.execution_handoff_status,
+                },
+                http_status: :ok,
+              )
+            rescue StandardError => error
+              mark_failed(communication)
+              failed = load_communication(communication_id)
+              if failed
+                CommandTower::Messaging::Handoff::OperationLogger.failed(
+                  communication: failed,
+                  error:,
+                )
+              end
+              failure(
+                errors: [CommandTower::Errors::InternalError.new(cause: error)],
+                http_status: :internal_server_error,
+                meta: { propagate_to_job: true },
+              )
+            end
+          end
+
+          private
+
+          def schedule_execution!(communication)
+            queued_ids = communication.channel_deliveries
+              .select { |delivery| delivery.status == CommandTower::Messaging::ChannelDelivery::STATUS_QUEUED }
+              .map(&:id)
+
+            CommandTower::Messaging::Execution::Scheduler.schedule_after_commit(queued_ids)
+          end
+
+          def load_communication(communication_id)
+            CommandTower::Messaging::Communication.includes(:channel_deliveries, :inbox_item).find_by(
+              id: communication_id,
+            )
+          end
+
+          def mark_failed(communication)
+            return if communication.nil?
+            return if communication.handoff_terminal?
+
+            communication.update(
+              execution_handoff_status: CommandTower::Messaging::Communication::HANDOFF_FAILED,
+            )
+          rescue StandardError
+            nil
+          end
+        end
+      end
+    end
+  end
+end

data/app/workflows/command_tower/workflows/messaging/inbox.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Messaging
+      module Inbox
+        class BaseWorkflow < CommandTower::Workflows::ApplicationWorkflow
+          retry_strategy :none
+
+          def self.inherited(subclass)
+            super
+            subclass.retry_strategy :none
+          end
+
+          private
+
+          def result_or_failure(result)
+            return result if result.success?
+
+            failure(errors: result.errors, http_status: CommandTower::Workflows::Messaging::ErrorMapping.http_status_for(result.errors.first))
+          end
+        end
+
+        class ListWorkflow < BaseWorkflow
+          def call(user:, limit:, offset:, scope:)
+            result = CommandTower::Services::Messaging::Inbox::List.call(user:, limit:, offset:, scope:)
+            return result_or_failure(result) unless result.success?
+
+            payload = result.data[:items].map { |item| CommandTower::Serializers::Messaging::Inbox::ItemSerializer.serialize(item) }
+            meta = CommandTower::Serializers::Messaging::Inbox::PaginationMetaSerializer.serialize(result.data[:pagination])
+            success(payload:, meta:, http_status: :ok)
+          end
+        end
+
+        class ShowWorkflow < BaseWorkflow
+          def call(user:, inbox_item_id:)
+            result = CommandTower::Services::Messaging::Inbox::Show.call(user:, inbox_item_id:)
+            return result_or_failure(result) unless result.success?
+
+            success(payload: CommandTower::Serializers::Messaging::Inbox::DetailSerializer.serialize(result.data[:item]), http_status: :ok)
+          end
+        end
+
+        class OpenWorkflow < ShowWorkflow
+          def call(user:, inbox_item_id:)
+            result = CommandTower::Services::Messaging::Inbox::Open.call(user:, inbox_item_id:)
+            return result_or_failure(result) unless result.success?
+
+            success(payload: CommandTower::Serializers::Messaging::Inbox::DetailSerializer.serialize(result.data[:item]), http_status: :ok)
+          end
+        end
+
+        class ArchiveWorkflow < BaseWorkflow
+          def call(user:, inbox_item_id:)
+            result = CommandTower::Services::Messaging::Inbox::Archive.call(user:, inbox_item_id:)
+            return result_or_failure(result) unless result.success?
+
+            success(payload: CommandTower::Serializers::Messaging::Inbox::ItemSerializer.serialize(result.data[:item]), http_status: :ok)
+          end
+        end
+
+        class DeleteWorkflow < BaseWorkflow
+          def call(user:, inbox_item_id:)
+            result = CommandTower::Services::Messaging::Inbox::Delete.call(user:, inbox_item_id:)
+            return result_or_failure(result) unless result.success?
+
+            success(payload: nil, http_status: :ok)
+          end
+        end
+
+        class UnreadCountWorkflow < BaseWorkflow
+          def call(user:)
+            result = CommandTower::Services::Messaging::Inbox::UnreadCount.call(user:)
+            return result_or_failure(result) unless result.success?
+
+            success(payload: CommandTower::Serializers::Messaging::Inbox::UnreadCountSerializer.serialize(result.data), http_status: :ok)
+          end
+        end
+
+        { BulkReadWorkflow: :BulkRead, BulkUnreadWorkflow: :BulkUnread, BulkArchiveWorkflow: :BulkArchive,
+          BulkRestoreWorkflow: :BulkRestore, BulkDeleteWorkflow: :BulkDelete }.each do |workflow_name, service_name|
+          const_set(workflow_name, Class.new(BaseWorkflow) do
+            define_method(:call) do |user:, inbox_item_ids:|
+              result = CommandTower::Services::Messaging::Inbox.const_get(service_name).call(user:, inbox_item_ids:)
+              return result_or_failure(result) unless result.success?
+
+              success(
+                payload: CommandTower::Serializers::Messaging::Inbox::BulkResultSerializer.serialize(result.data[:bulk_result]),
+                http_status: :ok
+              )
+            end
+          end)
+        end
+      end
+    end
+  end
+end

data/app/workflows/command_tower/workflows/messaging/preferences/show_workflow.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Messaging
+      module Preferences
+        class ShowWorkflow < CommandTower::Workflows::ApplicationWorkflow
+          retry_strategy :none
+
+          def call(user:)
+            result = CommandTower::Services::Messaging::Preferences::Show.call(user:)
+
+            unless result.success?
+              error = result.errors.first
+              return failure(
+                errors: result.errors,
+                http_status: CommandTower::Workflows::Messaging::ErrorMapping.http_status_for(error)
+              )
+            end
+
+            payload = CommandTower::Serializers::Messaging::Preferences::CatalogSerializer.serialize(
+              result.data[:catalog],
+            )
+
+            success(payload:, http_status: :ok)
+          end
+        end
+      end
+    end
+  end
+end

data/app/workflows/command_tower/workflows/messaging/preferences/update_workflow.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module CommandTower
+  module Workflows
+    module Messaging
+      module Preferences
+        class UpdateWorkflow < CommandTower::Workflows::ApplicationWorkflow
+          retry_strategy :none
+
+          def call(user:, notification_type_key:, preference_state:)
+            result = CommandTower::Services::Messaging::Preferences::Update.call(
+              user:,
+              notification_type_key:,
+              preference_state:,
+            )
+
+            unless result.success?
+              error = result.errors.first
+              return failure(
+                errors: result.errors,
+                http_status: CommandTower::Workflows::Messaging::ErrorMapping.http_status_for(error)
+              )
+            end
+
+            payload = {
+              notification: CommandTower::Serializers::Messaging::Preferences::NotificationSerializer.serialize(
+                result.data[:notification],
+              ),
+            }
+
+            success(payload:, http_status: :ok)
+          end
+        end
+      end
+    end
+  end
+end