jumbotron 0.1.1

data/app/workflows/jumbotron/workflows/execute_discovery_workflow.rb

@@ -0,0 +1,131 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class ExecuteDiscoveryWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      retry_strategy :delayed_continuation, max_attempts: 24
+
+      CONTENTION_WAIT_SECONDS = 5
+
+      def call(adapter_id:, discovery_id:)
+        resolved = Services::Adapters::ResolveDiscovery.call(
+          adapter_id: adapter_id,
+          discovery_id: discovery_id
+        )
+        return map_resolution_failure(resolved) unless resolved.success?
+
+        adapter = resolved.data[:adapter]
+        definition = resolved.data[:definition]
+        ensured = Services::Adapters::EnsureLeague.call(adapter: adapter)
+        return map_resolution_failure(ensured) unless ensured.success?
+
+        league = ensured.data[:league]
+        return cooldown_deferred(adapter) if adapter.provider_cooling_down?
+
+        expanded = adapter.scopes_for_discovery(definition)
+        return map_expand_failure(adapter, expanded) unless expanded.success?
+
+        scopes = Array(expanded.output).map do |acquisition|
+          { endpoint: definition.endpoint, acquisition: acquisition }
+        end
+        return empty_scopes_failure(adapter, definition) if scopes.empty?
+
+        run_scopes(adapter, league, scopes, discovery_id)
+      end
+
+      private
+
+      def run_scopes(adapter, league, scopes, discovery_id)
+        scopes.each do |scope|
+          return cooldown_deferred(adapter) if adapter.provider_cooling_down?
+
+          executed = Services::Adapters::ExecuteSynchronizationScope.call(
+            adapter: adapter,
+            league: league,
+            endpoint: scope.fetch(:endpoint),
+            acquisition: scope.fetch(:acquisition)
+          )
+          classified = classify_scope(adapter, executed)
+          return classified unless classified.nil?
+        end
+
+        success(
+          payload: { adapter_id: adapter.adapter_id, discovery_id: discovery_id.to_s },
+          http_status: :ok
+        )
+      end
+
+      def classify_scope(adapter, executed)
+        unless executed.success?
+          return failure(
+            errors: [{ code: "discovery_execution_failed", message: "synchronization scope failed" }],
+            http_status: :unprocessable_entity,
+            meta: { failure_class: "mutation" }
+          )
+        end
+
+        data = executed.data
+        case data[:outcome]
+        when :succeeded
+          nil
+        when :contention
+          deferred(reason: :lease_contention, retry_after: CONTENTION_WAIT_SECONDS)
+        when :cooldown_active
+          cooldown_deferred(adapter)
+        else
+          classify_failed_scope(adapter, data)
+        end
+      end
+
+      def classify_failed_scope(adapter, data)
+        return cooldown_deferred(adapter) if data[:failure_class] == "acquisition"
+
+        failure(
+          errors: [{ code: "discovery_execution_failed", message: "canonical or transform failure" }],
+          http_status: :unprocessable_entity,
+          meta: { failure_class: data[:failure_class] || "mutation" }
+        )
+      end
+
+      def map_expand_failure(adapter, expanded)
+        return cooldown_deferred(adapter) if adapter.provider_cooling_down?
+
+        error = expanded.respond_to?(:error) ? expanded.error : nil
+        failure(
+          errors: [{
+            code: "discovery_expansion_failed",
+            message: error.respond_to?(:message) ? error.message : "discovery expansion failed"
+          }],
+          http_status: :unprocessable_entity,
+          meta: { failure_class: "validation" }
+        )
+      end
+
+      def empty_scopes_failure(adapter, definition)
+        failure(
+          errors: [{
+            code: "discovery_expansion_failed",
+            message: "discovery #{definition.id} produced no acquisition scopes"
+          }],
+          http_status: :unprocessable_entity,
+          meta: { failure_class: "validation", adapter_id: adapter.adapter_id }
+        )
+      end
+
+      def cooldown_deferred(adapter)
+        wait = [Integer(adapter.provider_retry_after), 1].max
+        deferred(reason: :provider_cooldown, retry_after: wait)
+      end
+
+      def map_resolution_failure(result)
+        error = Array(result.errors).first
+        code = error.respond_to?(:code) ? error.code : "unknown_adapter"
+        failure(
+          errors: [{ code: code, message: error.respond_to?(:message) ? error.message : error.to_s }],
+          http_status: :unprocessable_entity,
+          meta: { failure_class: "validation" }
+        )
+      end
+    end
+  end
+end

data/app/workflows/jumbotron/workflows/execute_game_update_policy_workflow.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class ExecuteGameUpdatePolicyWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      retry_strategy :scheduled_cadence
+
+      def call(adapter_id:, policy_id:)
+        now = Time.current
+        resolved = Services::Adapters::ResolveGameUpdatePolicy.call(
+          adapter_id: adapter_id,
+          policy_id: policy_id
+        )
+        return map_resolution_failure(resolved) unless resolved.success?
+
+        adapter = resolved.data[:adapter]
+        policy = resolved.data[:policy]
+        selected = Services::Adapters::SelectEligibleGames.call(
+          adapter: adapter,
+          policy: policy,
+          now: now
+        )
+        return map_selection_failure(selected) unless selected.success?
+
+        league = selected.data[:league]
+        games = selected.data[:games]
+        built = Services::Adapters::BuildAcquisitionScopes.call(adapter: adapter, games: games)
+        return map_selection_failure(built) unless built.success?
+
+        scopes = built.data[:scopes]
+        counts = blank_counts.merge(
+          eligible_games: games.size,
+          unique_scopes: scopes.size,
+          skipped_incomplete_scope: built.data[:skipped_incomplete_scope]
+        )
+
+        return success_payload(adapter, policy, counts) if scopes.empty?
+
+        run_scopes(adapter, league, scopes, counts)
+        finish(adapter, policy, counts)
+      end
+
+      private
+
+      def run_scopes(adapter, league, scopes, counts)
+        scopes.each_with_index do |scope, index|
+          if adapter.provider_cooling_down?
+            counts[:skipped_cooldown] += scopes.size - index
+            break
+          end
+
+          handle_scope(adapter, league, scope, counts)
+          next unless counts[:stop_remaining]
+
+          remaining = scopes.size - index - 1
+          counts[:skipped_cooldown] += remaining if remaining.positive?
+          break
+        end
+        counts.delete(:stop_remaining)
+      end
+
+      def handle_scope(adapter, league, scope, counts)
+        executed = Services::Adapters::ExecuteSynchronizationScope.call(
+          adapter: adapter,
+          league: league,
+          endpoint: scope.fetch(:endpoint),
+          acquisition: scope.fetch(:acquisition)
+        )
+        unless executed.success?
+          counts[:failed_scopes] += 1
+          counts[:failure_class] ||= "mutation"
+          return
+        end
+
+        record_scope_outcome(executed.data, counts)
+      end
+
+      def record_scope_outcome(data, counts)
+        case data[:outcome]
+        when :succeeded
+          counts[:succeeded_scopes] += 1
+        when :contention
+          counts[:skipped_contention] += 1
+        when :cooldown_active
+          counts[:skipped_cooldown] += 1
+          counts[:stop_remaining] = true
+        else
+          counts[:failed_scopes] += 1
+          counts[:failure_class] ||= data[:failure_class]
+          counts[:stop_remaining] = true if data[:failure_class] == "acquisition"
+        end
+      end
+
+      def finish(adapter, policy, counts)
+        payload = result_payload(adapter, policy, counts)
+        if counts[:failed_scopes].positive?
+          return failure(
+            errors: [{ code: "policy_execution_failed", message: "one or more scopes failed" }],
+            http_status: counts[:failure_class] == "acquisition" ? :bad_gateway : :unprocessable_entity,
+            meta: { failure_class: counts[:failure_class] || "mutation", execution: payload }
+          )
+        end
+
+        success(payload: payload, http_status: :ok)
+      end
+
+      def success_payload(adapter, policy, counts)
+        success(payload: result_payload(adapter, policy, counts), http_status: :ok)
+      end
+
+      def result_payload(adapter, policy, counts)
+        {
+          adapter_id: adapter.adapter_id,
+          policy_id: policy.id.to_s,
+          eligible_games: counts[:eligible_games],
+          unique_scopes: counts[:unique_scopes],
+          succeeded_scopes: counts[:succeeded_scopes],
+          skipped_contention: counts[:skipped_contention],
+          skipped_cooldown: counts[:skipped_cooldown],
+          skipped_incomplete_scope: counts[:skipped_incomplete_scope],
+          failed_scopes: counts[:failed_scopes]
+        }
+      end
+
+      def blank_counts
+        {
+          succeeded_scopes: 0,
+          skipped_contention: 0,
+          skipped_cooldown: 0,
+          skipped_incomplete_scope: 0,
+          failed_scopes: 0
+        }
+      end
+
+      def map_resolution_failure(result)
+        error = Array(result.errors).first
+        code = error.respond_to?(:code) ? error.code : "unknown_adapter"
+        failure(
+          errors: [{ code: code, message: error.respond_to?(:message) ? error.message : error.to_s }],
+          http_status: :unprocessable_entity,
+          meta: { failure_class: "validation" }
+        )
+      end
+
+      def map_selection_failure(result)
+        error = Array(result.errors).first
+        if error.is_a?(CommandTower::Errors::ApplicationError)
+          return failure(
+            errors: [error],
+            http_status: :unprocessable_entity,
+            meta: { failure_class: "validation" }
+          )
+        end
+
+        map_resolution_failure(result)
+      end
+    end
+  end
+end

data/app/workflows/jumbotron/workflows/execute_line_update_policy_workflow.rb

@@ -0,0 +1,156 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class ExecuteLineUpdatePolicyWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      retry_strategy :scheduled_cadence
+
+      def call(adapter_id:, policy_id:)
+        now = Time.current
+        resolved = Services::Adapters::ResolveLineUpdatePolicy.call(
+          adapter_id: adapter_id,
+          policy_id: policy_id
+        )
+        return map_resolution_failure(resolved) unless resolved.success?
+
+        adapter = resolved.data[:adapter]
+        policy = resolved.data[:policy]
+        selected = Services::Adapters::SelectEligibleGames.call(
+          adapter: adapter,
+          policy: policy,
+          now: now
+        )
+        return map_selection_failure(selected) unless selected.success?
+
+        games = selected.data[:games]
+        built = Services::Adapters::BuildLineAcquisitionScopes.call(adapter: adapter, games: games)
+        return map_selection_failure(built) unless built.success?
+
+        scopes = built.data[:scopes]
+        counts = blank_counts.merge(
+          eligible_games: games.size,
+          unique_scopes: scopes.size,
+          skipped_incomplete_scope: built.data[:skipped_incomplete_scope]
+        )
+
+        return success_payload(adapter, policy, counts) if scopes.empty?
+
+        run_scopes(adapter, scopes, counts)
+        finish(adapter, policy, counts)
+      end
+
+      private
+
+      def run_scopes(adapter, scopes, counts)
+        scopes.each_with_index do |scope, index|
+          if adapter.provider_cooling_down?
+            counts[:skipped_cooldown] += scopes.size - index
+            break
+          end
+
+          handle_scope(adapter, scope, counts)
+          next unless counts[:stop_remaining]
+
+          remaining = scopes.size - index - 1
+          counts[:skipped_cooldown] += remaining if remaining.positive?
+          break
+        end
+        counts.delete(:stop_remaining)
+      end
+
+      def handle_scope(adapter, scope, counts)
+        executed = Services::Adapters::ExecuteLineAcquisitionScope.call(
+          adapter: adapter,
+          acquisition: scope.fetch(:acquisition)
+        )
+        unless executed.success?
+          counts[:failed_scopes] += 1
+          counts[:failure_class] ||= "mutation"
+          return
+        end
+
+        record_scope_outcome(executed.data, counts)
+      end
+
+      def record_scope_outcome(data, counts)
+        case data[:outcome]
+        when :succeeded
+          counts[:succeeded_scopes] += 1
+        when :contention
+          counts[:skipped_contention] += 1
+        when :cooldown_active
+          counts[:skipped_cooldown] += 1
+          counts[:stop_remaining] = true
+        else
+          counts[:failed_scopes] += 1
+          counts[:failure_class] ||= data[:failure_class]
+          counts[:stop_remaining] = true if data[:failure_class] == "acquisition"
+        end
+      end
+
+      def finish(adapter, policy, counts)
+        payload = result_payload(adapter, policy, counts)
+        if counts[:failed_scopes].positive?
+          return failure(
+            errors: [{ code: "policy_execution_failed", message: "one or more scopes failed" }],
+            http_status: counts[:failure_class] == "acquisition" ? :bad_gateway : :unprocessable_entity,
+            meta: { failure_class: counts[:failure_class] || "mutation", execution: payload }
+          )
+        end
+
+        success(payload: payload, http_status: :ok)
+      end
+
+      def success_payload(adapter, policy, counts)
+        success(payload: result_payload(adapter, policy, counts), http_status: :ok)
+      end
+
+      def result_payload(adapter, policy, counts)
+        {
+          adapter_id: adapter.adapter_id,
+          policy_id: policy.id.to_s,
+          eligible_games: counts[:eligible_games],
+          unique_scopes: counts[:unique_scopes],
+          succeeded_scopes: counts[:succeeded_scopes],
+          skipped_contention: counts[:skipped_contention],
+          skipped_cooldown: counts[:skipped_cooldown],
+          skipped_incomplete_scope: counts[:skipped_incomplete_scope],
+          failed_scopes: counts[:failed_scopes]
+        }
+      end
+
+      def blank_counts
+        {
+          succeeded_scopes: 0,
+          skipped_contention: 0,
+          skipped_cooldown: 0,
+          skipped_incomplete_scope: 0,
+          failed_scopes: 0
+        }
+      end
+
+      def map_resolution_failure(result)
+        error = Array(result.errors).first
+        code = error.respond_to?(:code) ? error.code : "unknown_adapter"
+        failure(
+          errors: [{ code: code, message: error.respond_to?(:message) ? error.message : error.to_s }],
+          http_status: :unprocessable_entity,
+          meta: { failure_class: "validation" }
+        )
+      end
+
+      def map_selection_failure(result)
+        error = Array(result.errors).first
+        if error.is_a?(CommandTower::Errors::ApplicationError)
+          return failure(
+            errors: [error],
+            http_status: :unprocessable_entity,
+            meta: { failure_class: "validation" }
+          )
+        end
+
+        map_resolution_failure(result)
+      end
+    end
+  end
+end

data/app/workflows/jumbotron/workflows/public_read.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    module PublicRead
+      def map_deserializer_failure(deserialized)
+        error = Array(deserialized.errors).first
+        message =
+          if error.is_a?(Hash)
+            error[:message].presence || error[:code].to_s
+          else
+            error.to_s
+          end
+        failure(
+          errors: [{ code: "invalid_request", message: message.presence || "invalid_request" }],
+          http_status: :unprocessable_entity
+        )
+      end
+
+      def map_service_failure(result)
+        error = Array(result.errors).first
+        code = error.respond_to?(:code) ? error.code.to_s : "invalid_request"
+        message = error.respond_to?(:message) ? error.message : error.to_s
+        status = Public::TranslateOutcome::NOT_FOUND_CODES.include?(code) ? :not_found : :unprocessable_entity
+        failure(errors: [{ code: code, message: message }], http_status: status)
+      end
+    end
+  end
+end

data/app/workflows/jumbotron/workflows/read_consensus_workflow.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class ReadConsensusWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      include PublicRead
+
+      retry_strategy :none
+
+      def call(**kwargs)
+        deserialized = Deserializers::Public::GameIds.call(kwargs)
+        return map_deserializer_failure(deserialized) unless deserialized.success?
+
+        loaded = Services::Public::LoadGamesByIds.call(game_ids: deserialized.input.game_ids)
+        return map_service_failure(loaded) unless loaded.success?
+
+        games = loaded.data[:games]
+        resolved = Services::Public::ResolveCurrentLinesForGames.call(games: games)
+        return map_service_failure(resolved) unless resolved.success?
+
+        derived = Services::Public::DeriveConsensusForGames.call(
+          current_lines: resolved.data[:current_lines]
+        )
+        return map_service_failure(derived) unless derived.success?
+
+        mapped = Services::Public::MapPublicConsensusLines.call(
+          consensus_lines: derived.data[:consensus_lines],
+          current_lines: resolved.data[:current_lines],
+          include_constituents: false
+        )
+        return map_service_failure(mapped) unless mapped.success?
+
+        success(payload: { consensus_lines: mapped.data[:public_consensus_lines] }, http_status: :ok)
+      end
+    end
+  end
+end

data/app/workflows/jumbotron/workflows/read_current_lines_workflow.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class ReadCurrentLinesWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      include PublicRead
+
+      retry_strategy :none
+
+      def call(**kwargs)
+        deserialized = Deserializers::Public::GameIds.call(kwargs)
+        return map_deserializer_failure(deserialized) unless deserialized.success?
+
+        loaded = Services::Public::LoadGamesByIds.call(game_ids: deserialized.input.game_ids)
+        return map_service_failure(loaded) unless loaded.success?
+
+        resolved = Services::Public::ResolveCurrentLinesForGames.call(games: loaded.data[:games])
+        return map_service_failure(resolved) unless resolved.success?
+
+        mapped = Services::Public::MapPublicCurrentLines.call(current_lines: resolved.data[:current_lines])
+        return map_service_failure(mapped) unless mapped.success?
+
+        success(payload: { current_lines: mapped.data[:public_current_lines] }, http_status: :ok)
+      end
+    end
+  end
+end

data/app/workflows/jumbotron/workflows/read_game_workflow.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class ReadGameWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      include PublicRead
+
+      retry_strategy :none
+
+      def call(**kwargs)
+        deserialized = Deserializers::Public::Game.call(kwargs)
+        return map_deserializer_failure(deserialized) unless deserialized.success?
+
+        request = deserialized.input
+        read = Services::Public::ReadGame.call(game_id: request.id)
+        return map_service_failure(read) unless read.success?
+
+        game = read.data[:game]
+        included = Services::Public::LoadIncludedLines.call(games: [game], includes: request.includes)
+        return map_service_failure(included) unless included.success?
+
+        assembled = Services::Public::AssemblePublicGame.call(
+          game: game,
+          includes: request.includes,
+          current_lines: included.data[:current_lines],
+          consensus_lines: included.data[:consensus_lines]
+        )
+        return map_service_failure(assembled) unless assembled.success?
+
+        success(payload: { game: assembled.data[:public_game] }, http_status: :ok)
+      end
+    end
+  end
+end

data/app/workflows/jumbotron/workflows/read_schedule_groups_workflow.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class ReadScheduleGroupsWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      include PublicRead
+
+      retry_strategy :none
+
+      def call(**kwargs)
+        deserialized = Deserializers::Public::ScheduleGroups.call(kwargs)
+        return map_deserializer_failure(deserialized) unless deserialized.success?
+
+        read = Services::Public::ReadScheduleGroups.call(request: deserialized.input)
+        return map_service_failure(read) unless read.success?
+
+        success(payload: { schedule_groups: read.data[:schedule_groups] }, http_status: :ok)
+      end
+    end
+  end
+end

data/app/workflows/jumbotron/workflows/read_schedule_workflow.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class ReadScheduleWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      include PublicRead
+
+      retry_strategy :none
+
+      def call(**kwargs)
+        deserialized = Deserializers::Public::Schedule.call(kwargs)
+        return map_deserializer_failure(deserialized) unless deserialized.success?
+
+        request = deserialized.input
+        read = Services::Public::ReadSchedule.call(request: request)
+        return map_service_failure(read) unless read.success?
+
+        games = Array(read.data[:games])
+        included = Services::Public::LoadIncludedLines.call(games: games, includes: request.includes)
+        return map_service_failure(included) unless included.success?
+
+        public_games = games.map do |game|
+          assembled = Services::Public::AssemblePublicGame.call(
+            game: game,
+            includes: request.includes,
+            current_lines: included.data[:current_lines],
+            consensus_lines: included.data[:consensus_lines]
+          )
+          return map_service_failure(assembled) unless assembled.success?
+
+          assembled.data[:public_game]
+        end
+
+        schedule = Services::Public::AssemblePublicSchedule.call(
+          request: request,
+          league: read.data[:league],
+          season: read.data[:season],
+          season_phase: read.data[:season_phase],
+          schedule_group: read.data[:schedule_group],
+          public_games: public_games
+        )
+        return map_service_failure(schedule) unless schedule.success?
+
+        success(payload: { schedule: schedule.data[:schedule] }, http_status: :ok)
+      end
+    end
+  end
+end