jumbotron 0.1.1

data/app/workflows/jumbotron/workflows/synchronize_adapter_workflow.rb

@@ -0,0 +1,183 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Workflows
+    class SynchronizeAdapterWorkflow < CommandTower::Workflows::ApplicationWorkflow
+      retry_strategy :none
+
+      def call(adapter:, endpoint:, league_id:, observed_at: nil, acquisition: {})
+        observed_at ||= Time.current
+
+        validated = Jumbotron::Services::Adapters::ValidateSyncRequest.call(
+          adapter: adapter,
+          endpoint: endpoint,
+          league_id: league_id
+        )
+        return map_service_failure(validated, failure_class: "validation") unless validated.success?
+
+        executed = Jumbotron::Services::Adapters::ExecuteEndpoint.call(
+          adapter: adapter,
+          endpoint: endpoint,
+          observed_at: observed_at,
+          acquisition: acquisition || {}
+        )
+        return map_execute_failure(executed) unless executed.success?
+
+        transaction do
+          apply_canonical_sync!(
+            input: executed.data[:sync_input],
+            league: validated.data[:league],
+            provider: adapter.provider,
+            adapter_scope: "#{adapter.provider}:#{adapter.sport}:#{adapter.league}:#{endpoint}"
+          )
+        end
+      end
+
+      private
+
+      def apply_canonical_sync!(input:, league:, provider:, adapter_scope:)
+        unless input.is_a?(Jumbotron::Canonical::SyncInput)
+          fail_transaction!(
+            map_service_failure(
+              CommandTower::Services::ServiceResult.failure(
+                errors: [Jumbotron::Errors::Canonical::InvalidSyncInputError.new]
+              ),
+              failure_class: "mutation"
+            )
+          )
+        end
+
+        change_set = Jumbotron::Canonical::ChangeSet.new
+        teams = []
+
+        games = input.games.map do |game_input|
+          sync_one_game!(game_input, league, input.observed_at, change_set)
+        end
+
+        input.teams.each do |team_input|
+          team_result = Services::Canonical::UpsertTeam.call(
+            team_input: team_input,
+            observed_at: input.observed_at,
+            change_set: change_set
+          )
+          fail_on_service_failure!(team_result)
+          teams << team_result.data[:team]
+        end
+
+        evidence = Services::Canonical::RecordObservationEvidence.call(
+          change_set: change_set,
+          provider: provider,
+          adapter_scope: adapter_scope,
+          observed_at: input.observed_at
+        )
+        fail_on_service_failure!(evidence)
+
+        success(
+          payload: {
+            games: games,
+            teams: teams,
+            observation_batch_id: evidence.data[:observation_batch_id],
+            historical_change_count: evidence.data[:historical_change_count]
+          },
+          http_status: :ok
+        )
+      rescue ActiveRecord::RecordInvalid => e
+        fail_transaction!(
+          failure(
+            errors: [
+              Jumbotron::Errors::Canonical::MutationFailedError.new(details: { message: e.message })
+            ],
+            http_status: :unprocessable_entity,
+            meta: { failure_class: "mutation" }
+          )
+        )
+      end
+
+      def sync_one_game!(game_input, league, observed_at, change_set)
+        season_result = Services::Canonical::EnsureSeason.call(
+          league: league,
+          year: game_input.season_year
+        )
+        fail_on_service_failure!(season_result)
+
+        phase_result = Services::Canonical::EnsureSeasonPhase.call(
+          season: season_result.data[:season],
+          phase_key: game_input.season_phase_key
+        )
+        fail_on_service_failure!(phase_result)
+
+        group_result = Services::Canonical::EnsureScheduleGroup.call(
+          season: season_result.data[:season],
+          season_phase: phase_result.data[:season_phase],
+          schedule_group_input: game_input.schedule_group
+        )
+        fail_on_service_failure!(group_result)
+
+        venue_result = Services::Canonical::UpsertVenue.call(
+          venue_input: game_input.venue,
+          observed_at: observed_at,
+          change_set: change_set
+        )
+        fail_on_service_failure!(venue_result)
+
+        game_result = Services::Canonical::UpsertGame.call(
+          game_input: game_input,
+          league: league,
+          season: season_result.data[:season],
+          season_phase: phase_result.data[:season_phase],
+          schedule_group: group_result.data[:schedule_group],
+          venue: venue_result.data[:venue],
+          observed_at: observed_at,
+          change_set: change_set
+        )
+        fail_on_service_failure!(game_result)
+
+        game = game_result.data[:game]
+
+        attach = Services::Canonical::AttachProviderIdentities.call(
+          target: game,
+          refs: game_input.provider_identities
+        )
+        fail_on_service_failure!(attach)
+
+        game_input.participants.each do |participant_input|
+          gp_result = Services::Canonical::UpsertGameParticipant.call(
+            game: game,
+            participant_input: participant_input,
+            observed_at: observed_at,
+            change_set: change_set
+          )
+          fail_on_service_failure!(gp_result)
+        end
+
+        game
+      end
+
+      def fail_on_service_failure!(service_result)
+        return if service_result.success?
+
+        fail_transaction!(map_service_failure(service_result, failure_class: "mutation"))
+      end
+
+      def map_execute_failure(result)
+        error = Array(result.errors).first
+        code = error.respond_to?(:code) ? error.code : "normalization_failed"
+        failure(
+          errors: [{ code: code, message: error.respond_to?(:message) ? error.message : error.to_s }],
+          http_status: code == "acquisition_failed" ? :bad_gateway : :unprocessable_entity,
+          meta: { failure_class: code == "acquisition_failed" ? "acquisition" : "normalization" }
+        )
+      end
+
+      def map_service_failure(result, failure_class:)
+        error = Array(result.errors).first
+        code = error.respond_to?(:code) ? error.code : "#{failure_class}_failed"
+        failure(
+          errors: [{ code: code, message: error.respond_to?(:message) ? error.message : error.to_s }],
+          http_status: :unprocessable_entity,
+          meta: { failure_class: failure_class }
+        )
+      end
+    end
+  end
+end

data/db/migrate/20260812000001_create_jumbotron_foundational_catalog.rb

@@ -0,0 +1,68 @@
+# frozen_string_literal: true
+
+class CreateJumbotronFoundationalCatalog < ActiveRecord::Migration[8.1]
+  def change
+    create_sports
+    create_leagues
+    create_seasons
+    create_season_phases
+    create_provider_identities
+    index_provider_identities
+  end
+
+  private
+
+  def create_sports
+    create_table :jumbotron_sports do |t|
+      t.string :name, null: false
+      t.timestamps
+    end
+  end
+
+  def create_leagues
+    create_table :jumbotron_leagues do |t|
+      t.references :sport, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_sports }
+      t.string :name, null: false
+      t.timestamps
+    end
+  end
+
+  def create_seasons
+    create_table :jumbotron_seasons do |t|
+      t.references :league, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_leagues }
+      t.string :name, null: false
+      t.date :starts_on
+      t.date :ends_on
+      t.timestamps
+    end
+  end
+
+  def create_season_phases
+    create_table :jumbotron_season_phases do |t|
+      t.references :season, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_seasons }
+      t.string :name, null: false
+      t.timestamps
+    end
+  end
+
+  def create_provider_identities
+    create_table :jumbotron_provider_identities do |t|
+      t.string :provider, null: false, limit: 64
+      t.string :object_namespace, null: false, limit: 64
+      t.string :provider_id, null: false, limit: 191
+      t.string :target_type, null: false
+      t.bigint :target_id, null: false
+      t.timestamps
+    end
+  end
+
+  def index_provider_identities
+    add_index :jumbotron_provider_identities,
+              %i[provider object_namespace provider_id],
+              unique: true,
+              name: "idx_jumbotron_pi_identity"
+    add_index :jumbotron_provider_identities,
+              %i[target_type target_id],
+              name: "idx_jumbotron_pi_target"
+  end
+end

data/db/migrate/20260812000002_create_jumbotron_game_graph.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+class CreateJumbotronGameGraph < ActiveRecord::Migration[8.1]
+  def change
+    create_teams
+    create_venues
+    create_bookmakers
+    create_games
+    create_game_participants
+    index_game_participants
+  end
+
+  private
+
+  def create_teams
+    create_table :jumbotron_teams do |t|
+      t.string :name, null: false
+      t.timestamps
+    end
+  end
+
+  def create_venues
+    create_table :jumbotron_venues do |t|
+      t.string :name, null: false
+      t.timestamps
+    end
+  end
+
+  def create_bookmakers
+    create_table :jumbotron_bookmakers do |t|
+      t.string :name, null: false
+      t.timestamps
+    end
+  end
+
+  def create_games
+    create_table :jumbotron_games do |t|
+      add_game_references(t)
+      t.datetime :scheduled_at
+      t.string :lifecycle, null: false, default: "scheduled"
+      t.boolean :neutral_site, null: false, default: false
+      t.timestamps
+    end
+  end
+
+  def add_game_references(table)
+    table.references :league, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_leagues }
+    table.references :season, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_seasons }
+    table.references :season_phase, type: :bigint, foreign_key: { to_table: :jumbotron_season_phases }
+    table.references :venue, type: :bigint, foreign_key: { to_table: :jumbotron_venues }
+  end
+
+  def create_game_participants
+    create_table :jumbotron_game_participants do |t|
+      t.references :game, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_games }
+      t.references :team, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_teams }
+      t.string :role
+      t.integer :score
+      t.string :result
+      t.timestamps
+    end
+  end
+
+  def index_game_participants
+    add_index :jumbotron_game_participants,
+              %i[game_id team_id],
+              unique: true,
+              name: "idx_jumbotron_gp_game_team"
+  end
+end

data/db/migrate/20260812000003_add_freshness_to_jumbotron_provider_mutated_entities.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+class AddFreshnessToJumbotronProviderMutatedEntities < ActiveRecord::Migration[7.2]
+  TABLES = %w[
+    jumbotron_games
+    jumbotron_teams
+    jumbotron_venues
+    jumbotron_game_participants
+  ].freeze
+
+  def up
+    TABLES.each do |table|
+      add_column table, :observed_at, :datetime
+      add_column table, :changed_at, :datetime
+      execute <<~SQL.squish
+        UPDATE #{table}
+        SET observed_at = created_at, changed_at = created_at
+        WHERE observed_at IS NULL OR changed_at IS NULL
+      SQL
+      change_column_null table, :observed_at, false
+      change_column_null table, :changed_at, false
+    end
+  end
+
+  def down
+    TABLES.each do |table|
+      remove_column table, :observed_at
+      remove_column table, :changed_at
+    end
+  end
+end

data/db/migrate/20260812000004_create_jumbotron_observation_evidence.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+class CreateJumbotronObservationEvidence < ActiveRecord::Migration[7.2]
+  def change
+    create_table :jumbotron_observation_batches do |t|
+      t.string :provider, null: false
+      t.string :adapter_scope, null: false
+      t.datetime :observed_at, null: false
+      t.json :metadata
+      t.timestamps
+    end
+    add_index :jumbotron_observation_batches,
+              %i[provider adapter_scope observed_at],
+              name: "idx_jumbotron_obs_batches_scope_time"
+
+    create_table :jumbotron_historical_changes do |t|
+      t.references :observation_batch,
+                   null: false,
+                   foreign_key: { to_table: :jumbotron_observation_batches },
+                   index: { name: "idx_jumbotron_hist_changes_batch" }
+      t.string :subject_type, null: false
+      t.bigint :subject_id, null: false
+      t.string :attribute_name, null: false
+      t.json :previous_value
+      t.json :new_value
+      t.datetime :observed_at, null: false
+      t.string :provider, null: false
+      t.timestamps
+    end
+    add_index :jumbotron_historical_changes,
+              %i[subject_type subject_id],
+              name: "idx_jumbotron_hist_changes_subject"
+  end
+end

data/db/migrate/20260813000001_create_jumbotron_schedule_groups.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+class CreateJumbotronScheduleGroups < ActiveRecord::Migration[8.1]
+  def change
+    create_table :jumbotron_schedule_groups do |t|
+      t.references :season, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_seasons }
+      t.references :season_phase, type: :bigint, foreign_key: { to_table: :jumbotron_season_phases }
+      t.string :kind, null: false
+      t.integer :number
+      t.string :name, null: false
+      t.timestamps
+    end
+
+    add_index :jumbotron_schedule_groups,
+              %i[season_id season_phase_id kind name],
+              unique: true,
+              name: "idx_jumbotron_sg_identity"
+
+    add_reference :jumbotron_games,
+                  :schedule_group,
+                  type: :bigint,
+                  foreign_key: { to_table: :jumbotron_schedule_groups }
+  end
+end

data/db/migrate/20260814000001_create_jumbotron_line_observations.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+class CreateJumbotronLineObservations < ActiveRecord::Migration[8.1]
+  def change
+    add_column :jumbotron_bookmakers, :observed_at, :datetime
+    add_column :jumbotron_bookmakers, :changed_at, :datetime
+    reversible do |dir|
+      dir.up do
+        execute <<~SQL.squish
+          UPDATE jumbotron_bookmakers
+          SET observed_at = created_at, changed_at = created_at
+          WHERE observed_at IS NULL OR changed_at IS NULL
+        SQL
+      end
+    end
+    change_column_null :jumbotron_bookmakers, :observed_at, false
+    change_column_null :jumbotron_bookmakers, :changed_at, false
+
+    create_table :jumbotron_line_observations do |t|
+      t.references :game, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_games }
+      t.references :bookmaker, null: false, type: :bigint, foreign_key: { to_table: :jumbotron_bookmakers }
+      t.references :observation_batch, null: false, type: :bigint,
+                                       foreign_key: { to_table: :jumbotron_observation_batches }
+      t.string :market, null: false, limit: 32
+      t.string :outcome, null: false, limit: 32
+      t.string :source, null: false, limit: 32
+      t.decimal :line_value, precision: 8, scale: 3
+      t.integer :price_american
+      t.datetime :observed_at, null: false
+      t.datetime :changed_at, null: false
+      t.timestamps
+    end
+
+    add_index :jumbotron_line_observations,
+              %i[game_id bookmaker_id market outcome source observed_at],
+              name: "idx_jumbotron_line_obs_latest"
+  end
+end

data/db/migrate/20260820000001_add_progress_to_jumbotron_games.rb

@@ -0,0 +1,14 @@
+# frozen_string_literal: true
+
+class AddProgressToJumbotronGames < ActiveRecord::Migration[8.1]
+  def change
+    change_table :jumbotron_games do |t|
+      t.string :progress_state
+      t.string :progress_segment_kind
+      t.integer :progress_segment_number
+      t.string :progress_clock_mode
+      t.integer :progress_clock_seconds
+      t.string :progress_clock_display
+    end
+  end
+end

data/lib/jumbotron/client.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class Client
+    def schedule(**)
+      Public::TranslateOutcome.call(
+        Workflows::ReadScheduleWorkflow.call(**),
+        payload_key: :schedule
+      )
+    end
+
+    def schedule_groups(**)
+      Public::TranslateOutcome.call(
+        Workflows::ReadScheduleGroupsWorkflow.call(**),
+        payload_key: :schedule_groups
+      )
+    end
+
+    def game(**)
+      Public::TranslateOutcome.call(
+        Workflows::ReadGameWorkflow.call(**),
+        payload_key: :game
+      )
+    end
+
+    def consensus(**)
+      Public::TranslateOutcome.call(
+        Workflows::ReadConsensusWorkflow.call(**),
+        payload_key: :consensus_lines
+      )
+    end
+
+    def current_lines(**)
+      Public::TranslateOutcome.call(
+        Workflows::ReadCurrentLinesWorkflow.call(**),
+        payload_key: :current_lines
+      )
+    end
+  end
+end

data/lib/jumbotron/engine.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  class Engine < ::Rails::Engine
+    isolate_namespace Jumbotron
+
+    # Ensure app/synchronization is on Zeitwerk paths (alongside adapters/clients/providers).
+    config.autoload_paths << root.join("app/synchronization")
+    config.eager_load_paths << root.join("app/synchronization")
+    config.autoload_paths << root.join("app/scheduling")
+    config.eager_load_paths << root.join("app/scheduling")
+
+    config.autoload_paths << root.join("app/boot")
+    config.eager_load_paths << root.join("app/boot")
+
+    config.boot_discovery = true
+
+    # Reconcile jumbotron:* Sidekiq-Cron jobs on Sidekiq server start only.
+    # Do not require Sidekiq; skip when the host has not loaded Sidekiq-Cron.
+    config.after_initialize do
+      Jumbotron::Boot::EnqueueDiscoveries.call
+
+      next unless defined?(::Sidekiq) && defined?(::Sidekiq::Cron::Job)
+
+      ::Sidekiq.configure_server do |sidekiq|
+        sidekiq.on(:startup) do
+          Jumbotron::Scheduling::Materializer.call
+        end
+      end
+    end
+  end
+end

data/lib/jumbotron/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  VERSION = "0.1.1"
+end

data/lib/jumbotron.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+require "rails"
+require "command_tower"
+require "jumbotron/version"
+require "jumbotron/engine"
+require "jumbotron/client"
+
+module Jumbotron
+  def self.client
+    Client.new
+  end
+end

data/lib/tasks/jumbotron_schedules.rake

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+namespace :jumbotron do
+  namespace :schedules do
+    desc "Materialize Jumbotron recurring schedules into the host scheduler"
+    task materialize: :environment do
+      Jumbotron::Scheduling::Materializer.call(
+        solid_queue_path: ENV.fetch("JUMBOTRON_SOLID_QUEUE_RECURRING", nil)
+      )
+    end
+  end
+end