Poll Live Tennis Scores During a Match Window

id: tennis-live-scores-window
namespace: company.team
description: |
  Poll the Live Tennis API for in-play matches on a schedule that only runs
  during a configured match window, normalize the response into a compact
  scoreboard with JSONata, persist it to internal storage for downstream
  tasks, and log a one-line summary. Uses the free-tier-friendly cadence
  described below instead of continuous polling.

inputs:
  - id: tour
    type: SELECT
    defaults: ""
    required: false
    values:
      - ""
      - atp
      - wta
      - challenger
      - itf
      - juniors
    description: >
      Tour filter (bounded set). Leave as the empty option to return across
      every tour.

tasks:
  - id: fetch_live
    type: io.kestra.plugin.core.http.Request
    description: >
      Fetch the current in-play matches. The API key is read from the
      LIVETENNISAPI_KEY secret as the X-API-Key header, never hardcoded.
    uri: "https://api.livetennisapi.com/api/public/v1/matches?status=live{{
      inputs.tour != '' ? '&tour=' ~ inputs.tour : '' }}"
    method: GET
    headers:
      X-API-Key: "{{ secret('LIVETENNISAPI_KEY') }}"
      Accept: "application/json"
    options:
      allowFailed: false
    retry:
      type: exponential
      interval: PT2S
      maxInterval: PT20S
      maxAttempts: 3

  - id: build_scoreboard
    type: io.kestra.plugin.transform.jsonata.TransformValue
    description: >
      Normalize the response envelope and project each match down to the fields
      a scoreboard actually needs. Tolerant of the envelope key so a single
      expression covers matches / data.
    from: "{{ outputs.fetch_live.body }}"
    expression: |
      (
        $matches := $exists(matches) ? matches : ($exists(data) ? data : []);
        {
          "fetched_at": $now(),
          "count": $count($matches),
          "matches": $matches.{
            "id": id,
            "tour": tour,
            "status": status,
            "p1": players.p1.name,
            "p2": players.p2.name,
            "server": score.server,
            "score": score
          }
        }
      )

  - id: store_scoreboard
    type: io.kestra.plugin.core.storage.Write
    description: >
      Persist the normalized scoreboard to internal storage so downstream tasks
      (a warehouse load, a Slack post, a dashboard feed) can consume it via
      outputs.store_scoreboard.uri.
    content: "{{ outputs.build_scoreboard.value | json }}"
    extension: ".json"

  - id: log_summary
    type: io.kestra.plugin.core.log.Log
    description: Record how many live matches were captured this run.
    message: "Live tennis poll: {{ outputs.build_scoreboard.value | jq('.count') |
      first }} match(es) in play (tour filter: '{{ inputs.tour }}')."

triggers:
  - id: in_match_window
    type: io.kestra.plugin.core.trigger.Schedule
    description: >
      Every 15 minutes between 09:00 and 22:45 server time. That is roughly 56
      calls/day, which stays inside the free key's 100 req/day and 30 req/min
      limits. Edit the cron to match the hours your target tour actually plays;
      do NOT switch this to continuous 60-second polling on a free key (that
      would exceed the daily cap).
    cron: "*/15 9-22 * * *"

errors:
  - id: on_error
    type: io.kestra.plugin.core.log.Log
    level: ERROR
    message: "tennis-live-scores-window failed: {{ error.message }}"

outputs:
  - id: scoreboard_file
    type: STRING
    value: "{{ outputs.store_scoreboard.uri }}"
  - id: live_match_count
    type: STRING
    value: "{{ outputs.build_scoreboard.value | jq('.count') | first }}"