jumbotron 0.1.1

data/app/errors/jumbotron/errors/adapters.rb

@@ -0,0 +1,143 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Errors
+    module Adapters
+      class InvalidAdapterError < CommandTower::Errors::ApplicationError
+        def code
+          "invalid_adapter"
+        end
+
+        def message
+          "adapter is invalid"
+        end
+      end
+
+      class NotRegisteredError < CommandTower::Errors::ApplicationError
+        def code
+          "adapter_not_registered"
+        end
+
+        def message
+          adapter = details.is_a?(Hash) ? details[:adapter] : nil
+          adapter ? "#{adapter} is not registered" : "adapter is not registered"
+        end
+      end
+
+      class UnknownEndpointError < CommandTower::Errors::ApplicationError
+        def code
+          "unknown_endpoint"
+        end
+
+        def message
+          endpoint = details.is_a?(Hash) ? details[:endpoint] : nil
+          endpoint ? "adapter has no endpoint :#{endpoint}" : "unknown endpoint"
+        end
+      end
+
+      class LeagueNotFoundError < CommandTower::Errors::ApplicationError
+        def code
+          "league_not_found"
+        end
+
+        def message
+          league_id = details.is_a?(Hash) ? details[:league_id] : nil
+          league_id ? "league #{league_id} not found" : "league not found"
+        end
+      end
+
+      class AcquisitionFailedError < CommandTower::Errors::ApplicationError
+        def code
+          "acquisition_failed"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "provider acquisition failed"
+        end
+      end
+
+      class NormalizationFailedError < CommandTower::Errors::ApplicationError
+        def code
+          "normalization_failed"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "normalization failed"
+        end
+      end
+
+      class UnknownAdapterError < CommandTower::Errors::ApplicationError
+        def code
+          "unknown_adapter"
+        end
+
+        def message
+          adapter_id = details.is_a?(Hash) ? details[:adapter_id] : nil
+          adapter_id ? "unknown adapter #{adapter_id}" : "unknown adapter"
+        end
+      end
+
+      class UnknownPolicyError < CommandTower::Errors::ApplicationError
+        def code
+          "unknown_policy"
+        end
+
+        def message
+          policy_id = details.is_a?(Hash) ? details[:policy_id] : nil
+          policy_id ? "unknown policy #{policy_id}" : "unknown policy"
+        end
+      end
+
+      class DiscoveryNotExecutableError < CommandTower::Errors::ApplicationError
+        def code
+          "discovery_not_executable"
+        end
+
+        def message
+          "discovery is not executable as a game-update policy"
+        end
+      end
+
+      class UnknownDiscoveryError < CommandTower::Errors::ApplicationError
+        def code
+          "unknown_discovery"
+        end
+
+        def message
+          discovery_id = details.is_a?(Hash) ? details[:discovery_id] : nil
+          discovery_id ? "unknown discovery #{discovery_id}" : "unknown discovery"
+        end
+      end
+
+      class InvalidPolicyTypeError < CommandTower::Errors::ApplicationError
+        def code
+          "invalid_policy_type"
+        end
+
+        def message
+          "policy is not an executable game-update policy"
+        end
+      end
+
+      class InvalidLinePolicyTypeError < CommandTower::Errors::ApplicationError
+        def code
+          "invalid_policy_type"
+        end
+
+        def message
+          "policy is not an executable line-update policy"
+        end
+      end
+
+      class ProviderCooldownActiveError < CommandTower::Errors::ApplicationError
+        def code
+          "provider_cooldown_active"
+        end
+
+        def message
+          "provider cooldown is active"
+        end
+      end
+    end
+  end
+end

data/app/errors/jumbotron/errors/canonical.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Errors
+    module Canonical
+      class InvalidSyncInputError < CommandTower::Errors::ApplicationError
+        def code
+          "invalid_sync_input"
+        end
+
+        def message
+          "canonical input must be Canonical::SyncInput"
+        end
+      end
+
+      class ProviderIdentityConflictError < CommandTower::Errors::ApplicationError
+        def code
+          "provider_identity_conflict"
+        end
+
+        def message
+          "provider identity is already attached to a different target"
+        end
+      end
+
+      class MutationFailedError < CommandTower::Errors::ApplicationError
+        def code
+          "mutation_failed"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "canonical mutation failed"
+        end
+      end
+
+      class InvalidLineIngestError < CommandTower::Errors::ApplicationError
+        def code
+          "invalid_line_ingest"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "invalid line ingest"
+        end
+      end
+
+      class GameNotFoundError < CommandTower::Errors::ApplicationError
+        def code
+          "game_not_found"
+        end
+
+        def message
+          "canonical game was not found for the provided identities"
+        end
+      end
+
+      class ObservationEvidenceFailedError < CommandTower::Errors::ApplicationError
+        def code
+          "observation_evidence_failed"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "observation evidence failed"
+        end
+      end
+    end
+  end
+end

data/app/errors/jumbotron/errors/public.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Errors
+    module Public
+      class NotFoundError < CommandTower::Errors::ApplicationError
+        def code
+          details.is_a?(Hash) && details[:code].present? ? details[:code].to_s : "not_found"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "resource was not found"
+        end
+      end
+
+      class InvalidRequestError < CommandTower::Errors::ApplicationError
+        def code
+          "invalid_request"
+        end
+
+        def message
+          details.is_a?(Hash) && details[:message].present? ? details[:message].to_s : "invalid public request"
+        end
+      end
+    end
+  end
+end

data/app/errors/jumbotron/invalid_request_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class InvalidRequestError < Error
+  end
+end

data/app/errors/jumbotron/not_found_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class NotFoundError < Error
+  end
+end

data/app/errors/jumbotron/unsupported_capability_error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class UnsupportedCapabilityError < Error
+  end
+end

data/app/jobs/jumbotron/application_job.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class ApplicationJob < CommandTower::ApplicationJob
+  end
+end

data/app/jobs/jumbotron/discovery_job.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class DiscoveryJob < ApplicationJob
+    def perform(adapter_id:, discovery_id:, continuation_attempt: 1)
+      execute_workflow(
+        Workflows::ExecuteDiscoveryWorkflow,
+        adapter_id: adapter_id,
+        discovery_id: discovery_id,
+        continuation_attempt: continuation_attempt
+      )
+    end
+  end
+end

data/app/jobs/jumbotron/game_update_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class GameUpdateJob < ApplicationJob
+    def perform(adapter_id:, policy_id:)
+      Workflows::ExecuteGameUpdatePolicyWorkflow.call_from_job(
+        adapter_id: adapter_id,
+        policy_id: policy_id
+      )
+    end
+  end
+end

data/app/jobs/jumbotron/line_update_job.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class LineUpdateJob < ApplicationJob
+    def perform(adapter_id:, policy_id:)
+      Workflows::ExecuteLineUpdatePolicyWorkflow.call_from_job(
+        adapter_id: adapter_id,
+        policy_id: policy_id
+      )
+    end
+  end
+end

data/app/models/jumbotron/application_record.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+    self.table_name_prefix = "jumbotron_"
+  end
+end

data/app/models/jumbotron/bookmaker.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class Bookmaker < ApplicationRecord
+    has_many :provider_identities, as: :target, inverse_of: :target, dependent: :restrict_with_exception
+    has_many :line_observations, inverse_of: :bookmaker, dependent: :restrict_with_exception
+
+    validates :name, presence: true
+    validates :observed_at, :changed_at, presence: true
+  end
+end

data/app/models/jumbotron/canonical.rb

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Canonical
+    ProviderIdentityRef = Data.define(:provider, :namespace, :id)
+
+    TeamInput = Data.define(:provider_identities, :name)
+
+    VenueInput = Data.define(:provider_identities, :name)
+
+    ParticipantInput = Data.define(
+      :provider_identities,
+      :team_name,
+      :role,
+      :score,
+      :result
+    )
+
+    ScheduleGroupInput = Data.define(:kind, :number, :name)
+
+    GameSegment = Data.define(:kind, :number)
+    # Clock label text. Name is canonical/public contract, not Kernel#display.
+    GameClock = Data.define(:mode, :seconds, :display) # rubocop:disable Lint/DataDefineOverride
+    GameProgress = Data.define(:state, :segment, :clock)
+
+    GameInput = Data.define(
+      :provider_identities,
+      :scheduled_at,
+      :lifecycle,
+      :neutral_site,
+      :season_year,
+      :season_phase_key,
+      :schedule_group,
+      :venue,
+      :participants,
+      :progress
+    ) do
+      def initialize(progress: nil, **members)
+        super
+      end
+    end
+
+    SyncInput = Data.define(:observed_at, :games, :teams)
+
+    LineObservationInput = Data.define(
+      :bookmaker_identity,
+      :bookmaker_name,
+      :market,
+      :outcome,
+      :source,
+      :line_value,
+      :price_american
+    )
+
+    LineIngestInput = Data.define(
+      :observed_at,
+      :provider,
+      :adapter_scope,
+      :game_identities,
+      :observations
+    )
+
+    CurrentLine = Data.define(
+      :line_observation_id,
+      :game_id,
+      :bookmaker_id,
+      :bookmaker_name,
+      :market,
+      :outcome,
+      :line_value,
+      :price_american,
+      :observed_at,
+      :changed_at
+    )
+
+    ConsensusConstituent = Data.define(:line_observation_id, :bookmaker_id)
+
+    ConsensusLine = Data.define(
+      :game_id,
+      :market,
+      :outcome,
+      :line_value,
+      :constituent_count,
+      :constituents
+    )
+
+    # Transaction-local accumulator for material canonical attribute changes.
+    class ChangeSet
+      include Enumerable
+
+      Entry = Data.define(:subject, :attribute, :previous, :new_value)
+
+      def initialize
+        @entries = []
+      end
+
+      def record(subject:, attribute:, previous:, new_value:)
+        return if serialize(previous) == serialize(new_value)
+
+        @entries << Entry.new(
+          subject: subject,
+          attribute: attribute.to_s,
+          previous: previous,
+          new_value: new_value
+        )
+      end
+
+      delegate :any?, :size, to: :entries
+
+      def each(&)
+        entries.each(&)
+      end
+
+      private
+
+      attr_reader :entries
+
+      def serialize(value)
+        case value
+        when Time, ActiveSupport::TimeWithZone
+          value.iso8601
+        else
+          value
+        end
+      end
+    end
+  end
+end

data/app/models/jumbotron/game.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class Game < ApplicationRecord
+    LIFECYCLES = %w[
+      scheduled
+      in_progress
+      completed
+      postponed
+      cancelled
+      suspended
+    ].freeze
+
+    PROGRESS_STATES = %w[active intermission].freeze
+    PROGRESS_CLOCK_MODES = %w[remaining elapsed].freeze
+    PROGRESS_CORE_ATTRIBUTES = %i[
+      progress_state
+      progress_segment_kind
+      progress_segment_number
+    ].freeze
+    PROGRESS_CLOCK_ATTRIBUTES = %i[
+      progress_clock_mode
+      progress_clock_seconds
+      progress_clock_display
+    ].freeze
+    PROGRESS_ATTRIBUTES = (PROGRESS_CORE_ATTRIBUTES + PROGRESS_CLOCK_ATTRIBUTES).freeze
+
+    belongs_to :league, inverse_of: :games
+    belongs_to :season, inverse_of: :games
+    belongs_to :season_phase, optional: true, inverse_of: :games
+    belongs_to :schedule_group, optional: true, inverse_of: :games
+    belongs_to :venue, optional: true, inverse_of: :games
+    has_many :game_participants, inverse_of: :game, dependent: :restrict_with_exception
+    has_many :teams, through: :game_participants
+    has_many :provider_identities, as: :target, inverse_of: :target, dependent: :restrict_with_exception
+    has_many :line_observations, inverse_of: :game, dependent: :restrict_with_exception
+
+    attribute :lifecycle, :string, default: "scheduled"
+    attribute :neutral_site, :boolean, default: false
+
+    validates :lifecycle, inclusion: { in: LIFECYCLES }
+    validates :progress_state, inclusion: { in: PROGRESS_STATES, allow_nil: true }
+    validates :progress_clock_mode, inclusion: { in: PROGRESS_CLOCK_MODES, allow_nil: true }
+    validate :season_belongs_to_league
+    validate :season_phase_belongs_to_season
+    validate :schedule_group_belongs_to_season
+    validate :progress_is_all_nil_or_core_complete
+    validate :intermission_has_no_clock
+
+    private
+
+    def season_belongs_to_league
+      return if season.blank? || league.blank?
+      return if season.league_id == league_id
+
+      errors.add(:season, "must belong to the same league")
+    end
+
+    def season_phase_belongs_to_season
+      return if season_phase.blank? || season.blank?
+      return if season_phase.season_id == season_id
+
+      errors.add(:season_phase, "must belong to the same season")
+    end
+
+    def schedule_group_belongs_to_season
+      return if schedule_group.blank? || season.blank?
+      return if schedule_group.season_id == season_id
+
+      errors.add(:schedule_group, "must belong to the same season")
+    end
+
+    def progress_is_all_nil_or_core_complete
+      values = PROGRESS_ATTRIBUTES.map { |attribute| public_send(attribute) }
+      return if values.all?(&:nil?)
+      return if progress_core_complete?
+
+      errors.add(:progress_state, "must include state, segment kind, and segment number together")
+    end
+
+    def progress_core_complete?
+      progress_state.present? && progress_segment_kind.present? && !progress_segment_number.nil?
+    end
+
+    def intermission_has_no_clock
+      return unless progress_state == "intermission"
+      return if PROGRESS_CLOCK_ATTRIBUTES.all? { |attribute| public_send(attribute).nil? }
+
+      errors.add(:progress_clock_mode, "must be blank during intermission")
+    end
+  end
+end

data/app/models/jumbotron/game_participant.rb

@@ -0,0 +1,10 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class GameParticipant < ApplicationRecord
+    belongs_to :game, inverse_of: :game_participants
+    belongs_to :team, inverse_of: :game_participants
+
+    validates :team_id, uniqueness: { scope: :game_id }
+  end
+end

data/app/models/jumbotron/historical_change.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class HistoricalChange < ApplicationRecord
+    belongs_to :observation_batch, inverse_of: :historical_changes
+
+    validates :subject_type, :subject_id, :attribute_name, :observed_at, :provider, presence: true
+  end
+end

data/app/models/jumbotron/league.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class League < ApplicationRecord
+    belongs_to :sport, inverse_of: :leagues
+    has_many :seasons, inverse_of: :league, dependent: :restrict_with_exception
+    has_many :games, inverse_of: :league, dependent: :restrict_with_exception
+    has_many :provider_identities, as: :target, inverse_of: :target, dependent: :restrict_with_exception
+
+    validates :name, presence: true
+  end
+end

data/app/models/jumbotron/line_observation.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class LineObservation < ApplicationRecord
+    MARKETS = %w[spread total moneyline].freeze
+    OUTCOMES = %w[home away over under draw].freeze
+    SOURCES = %w[observed provider_open provider_close].freeze
+
+    belongs_to :game, inverse_of: :line_observations
+    belongs_to :bookmaker, inverse_of: :line_observations
+    belongs_to :observation_batch, inverse_of: :line_observations
+
+    validates :market, inclusion: { in: MARKETS }
+    validates :outcome, inclusion: { in: OUTCOMES }
+    validates :source, inclusion: { in: SOURCES }
+    validates :observed_at, :changed_at, presence: true
+  end
+end

data/app/models/jumbotron/observation_batch.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class ObservationBatch < ApplicationRecord
+    has_many :historical_changes,
+             inverse_of: :observation_batch,
+             dependent: :restrict_with_exception
+    has_many :line_observations,
+             inverse_of: :observation_batch,
+             dependent: :restrict_with_exception
+
+    validates :provider, :adapter_scope, :observed_at, presence: true
+  end
+end

data/app/models/jumbotron/provider_identity.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class ProviderIdentity < ApplicationRecord
+    TARGET_TYPES = [
+      "Jumbotron::Sport",
+      "Jumbotron::League",
+      "Jumbotron::Season",
+      "Jumbotron::SeasonPhase",
+      "Jumbotron::Team",
+      "Jumbotron::Venue",
+      "Jumbotron::Game",
+      "Jumbotron::Bookmaker"
+    ].freeze
+
+    belongs_to :target, polymorphic: true, inverse_of: :provider_identities
+
+    before_validation :normalize_provider
+
+    validates :provider, presence: true
+    validates :object_namespace, presence: true
+    validates :provider_id, presence: true
+    validates :target_type, inclusion: { in: TARGET_TYPES }
+    validates :provider_id, uniqueness: { scope: %i[provider object_namespace] }
+
+    private
+
+    def normalize_provider
+      self.provider = provider&.strip&.downcase
+    end
+  end
+end