jumbotron 0.1.1

data/app/deserializers/jumbotron/deserializers/clients/espn/season.rb

@@ -0,0 +1,27 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class Season
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :year, type: Support.types.integer, required: true
+            field :type, type: Support.types.integer, required: true
+            field :slug, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "season")
+
+            Result.build!(
+              year: Support.payload.fetch(payload, "year"),
+              type: Support.payload.fetch(payload, "type"),
+              slug: Support.payload.fetch(payload, "slug")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/status.rb

@@ -0,0 +1,69 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class Status
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :clock, type: Support.types.union(Support.types.integer, Support.types.string), nullable: true
+            field :display_clock, type: Support.types.string, nullable: true
+            field :period, type: Support.types.integer, nullable: true
+            field :type_id, type: Support.types.string, nullable: true
+            field :type_name, type: Support.types.string, required: true
+            field :type_state, type: Support.types.string, required: true
+            field :type_completed, type: Support.types.boolean, required: true
+            field :type_description, type: Support.types.string, nullable: true
+            field :type_detail, type: Support.types.string, nullable: true
+            field :type_short_detail, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "status")
+            type = fetch_type!(payload)
+
+            Result.build!(
+              clock: Support.whole_number(Support.payload.fetch(payload, "clock")),
+              display_clock: Support.payload.fetch(payload, "displayClock"),
+              period: Support.payload.fetch(payload, "period"),
+              type_id: coerce_string(Support.payload.fetch(type, "id")),
+              type_name: Support.payload.fetch(type, "name"),
+              type_state: Support.payload.fetch(type, "state"),
+              type_completed: Support.payload.fetch(type, "completed"),
+              type_description: Support.payload.fetch(type, "description"),
+              type_detail: Support.payload.fetch(type, "detail"),
+              type_short_detail: Support.payload.fetch(type, "shortDetail")
+            )
+          end
+
+          def self.fetch_type!(payload)
+            raw = Support.payload.fetch(payload, "type")
+            if raw.equal?(Support.missing) || raw.nil?
+              raise CommandTower::Clients::Errors::DeserializationError.new(
+                message: "status.type is required",
+                details: {
+                  path: "type",
+                  expected: "Hash",
+                  actual: "missing",
+                  rule: "required",
+                  messages: ["status.type is required"]
+                }
+              )
+            end
+
+            Support.ensure_hash!(raw, label: "status.type")
+            raw
+          end
+          private_class_method :fetch_type!
+
+          def self.coerce_string(raw)
+            return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
+
+            raw.to_s
+          end
+          private_class_method :coerce_string
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/support.rb

@@ -0,0 +1,61 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module Support
+          module_function
+
+          def types
+            CommandTower::Deserializers::Clients::Types
+          end
+
+          def payload
+            CommandTower::Deserializers::Clients::Payload
+          end
+
+          def missing
+            CommandTower::Deserializers::Clients::Missing
+          end
+
+          def ensure_hash!(value, label:)
+            return if value.is_a?(Hash)
+
+            raise CommandTower::Clients::Errors::DeserializationError.new(
+              message: "#{label} payload must be a Hash",
+              details: {
+                path: "",
+                expected: "Hash",
+                actual: value.class.name,
+                rule: "type",
+                messages: ["#{label} payload must be a Hash"]
+              }
+            )
+          end
+
+          def nest(key, raw)
+            return raw if raw.equal?(missing) || raw.nil?
+
+            yield raw
+          rescue CommandTower::Clients::Errors::DeserializationError => e
+            raise CommandTower::Deserializers::Clients::Errors.prefix(e, key)
+          end
+
+          def whole_number(raw)
+            return raw if raw.equal?(missing) || raw.nil?
+            return raw.to_i if raw.is_a?(Float) && raw == raw.to_i
+
+            raw
+          end
+
+          def coerce_id(raw)
+            return raw if raw.equal?(missing) || raw.nil? || raw.is_a?(String)
+
+            raw.to_s
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/team.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class Team
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :id, type: Support.types.string, required: true
+            field :uid, type: Support.types.string, nullable: true
+            field :abbreviation, type: Support.types.string, nullable: true
+            field :display_name, type: Support.types.string, required: true
+            field :short_display_name, type: Support.types.string, nullable: true
+            field :name, type: Support.types.string, nullable: true
+            field :location, type: Support.types.string, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "team")
+
+            Result.build!(
+              id: coerce_id(Support.payload.fetch(payload, "id")),
+              uid: Support.payload.fetch(payload, "uid"),
+              abbreviation: Support.payload.fetch(payload, "abbreviation"),
+              display_name: Support.payload.fetch(payload, "displayName"),
+              short_display_name: Support.payload.fetch(payload, "shortDisplayName"),
+              name: Support.payload.fetch(payload, "name"),
+              location: Support.payload.fetch(payload, "location")
+            )
+          end
+
+          def self.coerce_id(raw)
+            return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
+
+            raw.to_s
+          end
+          private_class_method :coerce_id
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/teams/get.rb

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        module Teams
+          class Get
+            def self.call(payload)
+              Support.ensure_hash!(payload, label: "teams")
+
+              teams_raw = extract_team_entries(payload)
+              teams_raw.each_with_index.map do |entry, index|
+                team_payload = entry.is_a?(Hash) ? (entry["team"] || entry) : entry
+                Team.call(team_payload)
+              rescue CommandTower::Clients::Errors::DeserializationError => e
+                raise CommandTower::Deserializers::Clients::Errors.prefix(e, "teams[#{index}]")
+              end
+            end
+
+            def self.extract_team_entries(payload)
+              sports = Support.payload.fetch(payload, "sports")
+              if sports.equal?(Support.missing) || !sports.is_a?(Array) || sports.empty?
+                raise CommandTower::Clients::Errors::DeserializationError.new(
+                  message: "sports[0] is required",
+                  details: {
+                    path: "sports",
+                    expected: "Array",
+                    actual: sports.equal?(Support.missing) ? "missing" : sports.class.name,
+                    rule: "required",
+                    messages: ["sports[0] is required"]
+                  }
+                )
+              end
+
+              sport = sports.first
+              Support.ensure_hash!(sport, label: "sports[0]")
+              leagues = Support.payload.fetch(sport, "leagues")
+              if leagues.equal?(Support.missing) || !leagues.is_a?(Array) || leagues.empty?
+                raise CommandTower::Clients::Errors::DeserializationError.new(
+                  message: "sports[0].leagues[0] is required",
+                  details: {
+                    path: "sports[0].leagues",
+                    expected: "Array",
+                    actual: leagues.equal?(Support.missing) ? "missing" : leagues.class.name,
+                    rule: "required",
+                    messages: ["sports[0].leagues[0] is required"]
+                  }
+                )
+              end
+
+              league = leagues.first
+              Support.ensure_hash!(league, label: "sports[0].leagues[0]")
+              teams = Support.payload.fetch(league, "teams")
+              if teams.equal?(Support.missing) || !teams.is_a?(Array)
+                raise CommandTower::Clients::Errors::DeserializationError.new(
+                  message: "sports[0].leagues[0].teams is required",
+                  details: {
+                    path: "sports[0].leagues[0].teams",
+                    expected: "Array",
+                    actual: teams.equal?(Support.missing) ? "missing" : teams.class.name,
+                    rule: "required",
+                    messages: ["sports[0].leagues[0].teams is required"]
+                  }
+                )
+              end
+
+              teams
+            end
+            private_class_method :extract_team_entries
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/venue.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class Venue
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :id, type: Support.types.string, required: true
+            field :full_name, type: Support.types.string, required: true
+            field :indoor, type: Support.types.boolean, nullable: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "venue")
+
+            Result.build!(
+              id: coerce_id(Support.payload.fetch(payload, "id")),
+              full_name: Support.payload.fetch(payload, "fullName"),
+              indoor: Support.payload.fetch(payload, "indoor")
+            )
+          end
+
+          def self.coerce_id(raw)
+            return raw if raw.equal?(Support.missing) || raw.nil? || raw.is_a?(String)
+
+            raw.to_s
+          end
+          private_class_method :coerce_id
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/clients/espn/week.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Clients
+      module Espn
+        class Week
+          class Result < CommandTower::Deserializers::Clients::Result
+            field :number, type: Support.types.integer, required: true
+          end
+
+          def self.call(payload)
+            Support.ensure_hash!(payload, label: "week")
+
+            Result.build!(
+              number: Support.payload.fetch(payload, "number")
+            )
+          end
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/public/game.rb

@@ -0,0 +1,26 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Public
+      class Game < CommandTower::Deserializers::ApplicationDeserializer
+        def call(params)
+          id_raw = unwrap(fetch_param(params, :id))
+          return id_raw if deserializer_result?(id_raw)
+          return failure(errors: [{ code: "invalid_request", message: "id is required" }]) if id_raw.nil?
+
+          id = unwrap(require_integer(id_raw, field: "id", min: 1))
+          return id if deserializer_result?(id)
+
+          include_raw = unwrap(fetch_param(params, :include))
+          return include_raw if deserializer_result?(include_raw)
+
+          includes = unwrap(Includes.parse(include_raw))
+          return includes if deserializer_result?(includes)
+
+          success(Jumbotron::Public::GameRequest.new(id: id, includes: includes))
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/public/game_ids.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Public
+      class GameIds < CommandTower::Deserializers::ApplicationDeserializer
+        def call(params)
+          raw = unwrap(fetch_param(params, :game_ids))
+          return raw if deserializer_result?(raw)
+          return failure(errors: [{ code: "invalid_request", message: "game_ids is required" }]) if raw.nil?
+          unless raw.is_a?(Array)
+            return failure(errors: [{ code: "invalid_request", message: "game_ids must be an array" }])
+          end
+
+          ids = []
+          raw.each do |item|
+            coerced = unwrap(require_integer(item, field: "game_ids", min: 1))
+            return coerced if deserializer_result?(coerced)
+
+            ids << coerced
+          end
+
+          success(Jumbotron::Public::GameIdsRequest.new(game_ids: ids.uniq))
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/public/includes.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Public
+      module Includes
+        module_function
+
+        def parse(raw)
+          return CommandTower::Deserializers::CoercionResult.ok([]) if raw.nil?
+
+          list = raw.is_a?(Array) ? raw : [raw]
+          symbols = list.map { |item| item.is_a?(String) ? item.strip.to_sym : item }
+          unless symbols.all? { |item| item.is_a?(Symbol) && item != :"" }
+            return CommandTower::Deserializers::CoercionResult.fail(code: "invalid_request", field: "include")
+          end
+
+          unknown = symbols - Jumbotron::Public::ALLOWED_INCLUDES
+          if unknown.any?
+            return CommandTower::Deserializers::CoercionResult.fail(
+              code: "invalid_request",
+              field: "include",
+              details: { unknown: unknown }
+            )
+          end
+
+          CommandTower::Deserializers::CoercionResult.ok(symbols.uniq)
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/public/schedule.rb

@@ -0,0 +1,151 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Public
+      class Schedule < CommandTower::Deserializers::ApplicationDeserializer
+        def call(params)
+          values = {}
+          %i[
+            league_id sport league season_id season season_phase schedule_group_id
+            group starts_at ends_at include
+          ].each do |key|
+            raw = unwrap(fetch_param(params, key))
+            return raw if deserializer_result?(raw)
+
+            values[key] = raw
+          end
+
+          league_id = optional_positive_integer(values[:league_id], "league_id")
+          return league_id if deserializer_result?(league_id)
+
+          season_id = optional_positive_integer(values[:season_id], "season_id")
+          return season_id if deserializer_result?(season_id)
+
+          schedule_group_id = optional_positive_integer(values[:schedule_group_id], "schedule_group_id")
+          return schedule_group_id if deserializer_result?(schedule_group_id)
+
+          sport = optional_name(values[:sport])
+          return sport if deserializer_result?(sport)
+
+          league = optional_name(values[:league])
+          return league if deserializer_result?(league)
+
+          season = optional_name(values[:season])
+          return season if deserializer_result?(season)
+
+          season_phase = optional_name(values[:season_phase])
+          return season_phase if deserializer_result?(season_phase)
+
+          group = parse_group(values[:group])
+          return group if deserializer_result?(group)
+
+          starts_at = parse_time(values[:starts_at], "starts_at")
+          return starts_at if deserializer_result?(starts_at)
+
+          ends_at = parse_time(values[:ends_at], "ends_at")
+          return ends_at if deserializer_result?(ends_at)
+
+          includes = unwrap(Includes.parse(values[:include]))
+          return includes if deserializer_result?(includes)
+
+          request = Jumbotron::Public::ScheduleRequest.new(
+            league_id: league_id,
+            sport: sport,
+            league: league,
+            season_id: season_id,
+            season: season,
+            season_phase: season_phase,
+            schedule_group_id: schedule_group_id,
+            group: group,
+            starts_at: starts_at,
+            ends_at: ends_at,
+            includes: includes
+          )
+          error = validate_modes(request)
+          return error if error
+
+          success(request)
+        end
+
+        private
+
+        def optional_positive_integer(raw, field)
+          return if raw.nil?
+
+          unwrap(require_integer(raw, field: field, min: 1))
+        end
+
+        def optional_name(raw)
+          return if raw.nil?
+
+          unwrap(require_string(raw, field: "name"))
+        end
+
+        def parse_group(raw)
+          return if raw.nil?
+          return failure(errors: [{ code: "invalid_request", message: "group must be a hash" }]) unless raw.is_a?(Hash)
+
+          hash = raw.respond_to?(:to_h) ? raw.to_h : raw
+          kind_raw = hash[:kind] || hash["kind"]
+          number_raw = hash[:number] || hash["number"]
+          kind = unwrap(require_string(kind_raw, field: "group.kind"))
+          return kind if deserializer_result?(kind)
+
+          number = unwrap(require_integer(number_raw, field: "group.number", min: 1))
+          return number if deserializer_result?(number)
+
+          { kind: kind, number: number }
+        end
+
+        def parse_time(raw, field)
+          return if raw.nil?
+          return raw if raw.is_a?(Time) || raw.is_a?(ActiveSupport::TimeWithZone)
+
+          failure(errors: [{ code: "invalid_request", message: "#{field} must be a Time" }])
+        end
+
+        def validate_modes(request)
+          has_league = request.league_id.present? || (request.sport.present? && request.league.present?)
+          unless has_league
+            return failure(
+              errors: [{ code: "invalid_request", message: "league_id or sport+league is required" }]
+            )
+          end
+
+          has_group = request.schedule_group_id.present? || request.group.present?
+          has_time = request.starts_at.present? && request.ends_at.present?
+          if has_group && has_time
+            return failure(
+              errors: [{ code: "invalid_request", message: "provide group or time range, not both" }]
+            )
+          end
+          if !has_group && !has_time
+            return failure(
+              errors: [{ code: "invalid_request", message: "provide group or starts_at/ends_at" }]
+            )
+          end
+          if has_time && (request.starts_at.blank? || request.ends_at.blank?)
+            return failure(
+              errors: [{ code: "invalid_request", message: "starts_at and ends_at are required together" }]
+            )
+          end
+          if has_group && request.schedule_group_id.blank?
+            unless request.season_id.present? || request.season.present?
+              return failure(
+                errors: [{ code: "invalid_request", message: "season_id or season is required for group queries" }]
+              )
+            end
+            if request.season_phase.blank?
+              return failure(
+                errors: [{ code: "invalid_request", message: "season_phase is required for group queries" }]
+              )
+            end
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/app/deserializers/jumbotron/deserializers/public/schedule_groups.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Jumbotron
+  module Deserializers
+    module Public
+      class ScheduleGroups < CommandTower::Deserializers::ApplicationDeserializer
+        def call(params)
+          values = {}
+          %i[league_id sport league season_id season season_phase kind].each do |key|
+            raw = unwrap(fetch_param(params, key))
+            return raw if deserializer_result?(raw)
+
+            values[key] = raw
+          end
+
+          league_id = optional_positive_integer(values[:league_id], "league_id")
+          return league_id if deserializer_result?(league_id)
+
+          season_id = optional_positive_integer(values[:season_id], "season_id")
+          return season_id if deserializer_result?(season_id)
+
+          sport = optional_name(values[:sport])
+          return sport if deserializer_result?(sport)
+
+          league = optional_name(values[:league])
+          return league if deserializer_result?(league)
+
+          season = optional_name(values[:season])
+          return season if deserializer_result?(season)
+
+          season_phase = optional_name(values[:season_phase])
+          return season_phase if deserializer_result?(season_phase)
+
+          kind = optional_name(values[:kind])
+          return kind if deserializer_result?(kind)
+
+          request = Jumbotron::Public::ScheduleGroupsRequest.new(
+            league_id: league_id,
+            sport: sport,
+            league: league,
+            season_id: season_id,
+            season: season,
+            season_phase: season_phase,
+            kind: kind
+          )
+          error = validate_modes(request)
+          return error if error
+
+          success(request)
+        end
+
+        private
+
+        def optional_positive_integer(raw, field)
+          return if raw.nil?
+
+          unwrap(require_integer(raw, field: field, min: 1))
+        end
+
+        def optional_name(raw)
+          return if raw.nil?
+
+          unwrap(require_string(raw, field: "name"))
+        end
+
+        def validate_modes(request)
+          has_league = request.league_id.present? || (request.sport.present? && request.league.present?)
+          unless has_league
+            return failure(
+              errors: [{ code: "invalid_request", message: "league_id or sport+league is required" }]
+            )
+          end
+
+          unless request.season_id.present? || request.season.present?
+            return failure(
+              errors: [{ code: "invalid_request", message: "season_id or season is required" }]
+            )
+          end
+
+          if request.season_phase.blank?
+            return failure(
+              errors: [{ code: "invalid_request", message: "season_phase is required" }]
+            )
+          end
+
+          nil
+        end
+      end
+    end
+  end
+end

data/app/errors/jumbotron/error.rb

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