inferno_session_browser 0.1.0

data/lib/inferno_session_browser/assets/app.js

@@ -0,0 +1,212 @@
+'use strict';
+(() => {
+  const root = document.body.dataset.browserPath;
+  const form = document.querySelector('#filters');
+  const rowsElement = document.querySelector('#session-rows');
+  const status = document.querySelector('#status');
+  const error = document.querySelector('#error');
+  const params = new URLSearchParams(window.location.search);
+  const expanded = new Map();
+  const labels = { never_run: 'Never run', queued: 'Queued', running: 'Running', waiting: 'Waiting', cancelling: 'Cancelling', idle: 'Idle' };
+  let currentRows = [];
+  let busy = false;
+  let pending = false;
+  let controller;
+  let initialized = false;
+  let optionsLoaded = false;
+
+  function element(tag, text, className) {
+    const node = document.createElement(tag);
+    if (text !== undefined) node.textContent = text;
+    if (className) node.className = className;
+    return node;
+  }
+  function showError(message) { error.textContent = message; error.hidden = !message; }
+  function value(key, fallback) { return params.get(key) || fallback; }
+  function page() { return Number(value('page', '1')); }
+  function saveUrl() { history.replaceState(null, '', `${location.pathname}${params.size ? `?${params}` : ''}`); }
+  function localInput(iso) {
+    if (!iso) return '';
+    const date = new Date(iso);
+    if (Number.isNaN(date.getTime())) return '';
+    const offset = date.getTimezoneOffset() * 60000;
+    return new Date(date.getTime() - offset).toISOString().slice(0, 19);
+  }
+  function restoreControls() {
+    for (const control of form.elements) {
+      if (!control.name) continue;
+      control.value = ['from', 'to'].includes(control.name) ? localInput(params.get(control.name)) : value(control.name, control.name === 'date_field' ? 'created_at' : '');
+    }
+    document.querySelector('#sort').value = value('sort', 'latest_activity');
+    document.querySelector('#direction').value = value('direction', 'desc');
+    document.querySelector('#page-size').value = value('page_size', '25');
+  }
+  async function request(path, signal) {
+    const response = await fetch(`${root}${path}`, { signal, headers: { Accept: 'application/json' }, cache: 'no-store' });
+    let body;
+    try { body = await response.json(); } catch (_) { throw new Error('The server returned an unexpected response.'); }
+    if (!response.ok) throw new Error(body.error || 'Unable to load sessions.');
+    return body;
+  }
+  async function loadOptions() {
+    try {
+      const choices = await request('/api/options');
+      const suiteControl = form.elements.suite_id;
+      const selectedSuite = optionsLoaded ? suiteControl.value : value('suite_id', '');
+      suiteControl.replaceChildren(new Option('All suites', ''));
+      for (const suite of choices.suites) suiteControl.add(new Option(suite.title, suite.id));
+      if (selectedSuite && !choices.suites.some(suite => suite.id === selectedSuite)) suiteControl.add(new Option(selectedSuite, selectedSuite));
+      suiteControl.value = selectedSuite;
+      const optionContainer = document.querySelector('#option-filters');
+      const oldSelections = new Map(Array.from(optionContainer.querySelectorAll('select')).map(control => [control.name, control.value]));
+      optionContainer.replaceChildren();
+      for (const option of choices.suite_options) {
+        const label = element('label', option.title);
+        const select = element('select');
+        select.name = `suite_options[${option.id}]`;
+        select.add(new Option('All versions / values', ''));
+        for (const choice of option.values) select.add(new Option(choice.label, choice.value));
+        select.value = oldSelections.get(select.name) ?? value(select.name, '');
+        label.append(select); optionContainer.append(label);
+      }
+      document.querySelector('#options-error').textContent = '';
+      optionsLoaded = true;
+    } catch (_) { document.querySelector('#options-error').textContent = 'Filter choices could not be loaded. Refresh to retry.'; }
+  }
+  function dateCell(iso) {
+    const cell = element('td', undefined, 'time');
+    if (!iso) { cell.textContent = '—'; return cell; }
+    const date = new Date(iso);
+    const time = element('time', date.toLocaleDateString());
+    time.dateTime = iso;
+    time.title = date.toLocaleString();
+    time.append(element('small', date.toLocaleTimeString()));
+    cell.append(time); return cell;
+  }
+  function badge(text, type) { return element('span', text, `badge ${type || ''}`); }
+  function countsCell(counts) {
+    const cell = element('td');
+    const container = element('div', undefined, 'counts');
+    for (const [result, count] of Object.entries(counts)) if (count) container.append(badge(`${count} ${result}`, result));
+    if (!container.childNodes.length) container.append(element('span', 'No results', 'muted'));
+    cell.append(container); return cell;
+  }
+  function historyPanel(id) {
+    const state = expanded.get(id);
+    const panel = element('div');
+    panel.append(element('p', 'Run history', 'history-title'));
+    if (state.error) { const alert = element('p', state.error, 'history-error'); alert.setAttribute('role', 'alert'); panel.append(alert); }
+    if (!state.data) { panel.append(element('p', state.error ? 'Use Refresh now to retry.' : 'Loading run history…', 'muted')); return panel; }
+    if (!state.data.data.length) { panel.append(element('p', 'This session has no runs.', 'muted')); return panel; }
+    const table = element('table', undefined, 'history-table');
+    const head = element('thead'); const headRow = element('tr');
+    for (const title of ['Run / target', 'Execution status', 'Created', 'Last update', 'Target outcome', 'Test results']) { const th = element('th', title); th.scope = 'col'; headRow.append(th); }
+    head.append(headRow); table.append(head);
+    const body = element('tbody');
+    for (const run of state.data.data) {
+      const row = element('tr');
+      const target = element('td'); target.append(element('div', run.target.title, 'suite-title'), element('div', `${run.target.type} · ${run.id}`, 'muted')); row.append(target);
+      const runState = element('td'); runState.append(badge(run.status, run.status)); row.append(runState, dateCell(run.created_at), dateCell(run.updated_at));
+      const outcome = element('td'); outcome.append(run.outcome ? badge(run.outcome, run.outcome) : element('span', '—')); row.append(outcome, countsCell(run.result_counts)); body.append(row);
+    }
+    table.append(body); panel.append(table);
+    const pagination = element('nav', undefined, 'history-pagination'); pagination.setAttribute('aria-label', `Run history pagination for ${id}`);
+    const previous = element('button', 'Previous runs'); previous.type = 'button'; previous.disabled = state.page <= 1;
+    previous.dataset.focusKey = `runs-previous-${id}`;
+    previous.addEventListener('click', () => { state.page--; refresh(); });
+    const next = element('button', 'Next runs'); next.type = 'button'; next.disabled = state.page * 25 >= state.data.pagination.total;
+    next.dataset.focusKey = `runs-next-${id}`;
+    next.addEventListener('click', () => { state.page++; refresh(); });
+    pagination.append(previous, element('span', `Page ${state.page} · ${state.data.pagination.total} runs`, 'muted'), next); panel.append(pagination);
+    return panel;
+  }
+  function renderRows() {
+    const focusKey = document.activeElement?.dataset.focusKey;
+    rowsElement.replaceChildren();
+    if (!currentRows.length) { const row = element('tr'); const cell = element('td', 'No sessions match these filters.', 'empty-row'); cell.colSpan = 9; row.append(cell); rowsElement.append(row); return; }
+    for (const session of currentRows) {
+      const row = element('tr'); row.dataset.sessionId = session.id;
+      row.append(element('td', session.id, 'session-id'));
+      const suite = element('td'); suite.append(element('div', session.suite_title, 'suite-title'));
+      for (const option of session.suite_options) suite.append(element('div', `${option.title}: ${option.label}`, 'suite-options'));
+      if (!session.suite_available) suite.append(element('div', 'Suite unavailable', 'muted'));
+      row.append(suite, element('td', session.fhir_url || '—', 'fhir-url'), dateCell(session.created_at), dateCell(session.latest_activity));
+      const state = element('td'); state.append(badge(labels[session.state] || session.state, session.state)); row.append(state, element('td', session.run_count), countsCell(session.result_counts));
+      const actions = element('td', undefined, 'actions');
+      if (session.session_url) { const link = element('a', 'Open session'); link.href = session.session_url; actions.append(link); }
+      const expand = element('button', expanded.has(session.id) ? 'Hide history' : 'Run history', 'expand-button');
+      expand.type = 'button'; expand.dataset.focusKey = `expand-${session.id}`;
+      expand.setAttribute('aria-expanded', String(expanded.has(session.id))); expand.setAttribute('aria-controls', `history-${session.id}`);
+      expand.addEventListener('click', () => {
+        if (expanded.has(session.id)) expanded.delete(session.id); else expanded.set(session.id, { page: 1, data: null, error: null });
+        renderRows(); if (expanded.has(session.id)) refresh();
+      });
+      actions.append(expand); row.append(actions); rowsElement.append(row);
+      if (expanded.has(session.id)) { const historyRow = element('tr'); const cell = element('td', undefined, 'history-cell'); cell.colSpan = 9; cell.id = `history-${session.id}`; cell.append(historyPanel(session.id)); historyRow.append(cell); rowsElement.append(historyRow); }
+    }
+    if (focusKey) rowsElement.querySelector(`[data-focus-key="${CSS.escape(focusKey)}"]`)?.focus({ preventScroll: true });
+  }
+  async function refresh() {
+    if (busy) { pending = true; return; }
+    busy = true; pending = false;
+    controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 15000);
+    const query = params.toString();
+    const table = document.querySelector('#sessions-table'); table.setAttribute('aria-busy', 'true');
+    if (!initialized) status.textContent = 'Loading sessions…';
+    try {
+      const response = await request(`/api/sessions?${query}`, controller.signal);
+      if (query !== params.toString()) { pending = true; return; }
+      currentRows = response.data; initialized = true; showError('');
+      const total = response.pagination.total;
+      const start = total && currentRows.length ? (response.pagination.page - 1) * response.pagination.page_size + 1 : 0;
+      status.textContent = `Showing ${start}–${start ? start + currentRows.length - 1 : 0} of ${total} sessions`;
+      document.querySelector('#page-number').textContent = `Page ${response.pagination.page}`;
+      document.querySelector('#previous-page').disabled = page() <= 1;
+      document.querySelector('#next-page').disabled = page() * response.pagination.page_size >= total;
+      renderRows();
+      await Promise.all(currentRows.filter(session => expanded.has(session.id)).map(async session => {
+        const state = expanded.get(session.id); const requestedPage = state.page;
+        try {
+          const result = await request(`/api/sessions/${encodeURIComponent(session.id)}/runs?page=${requestedPage}`, controller.signal);
+          if (expanded.get(session.id) === state && state.page === requestedPage) { state.data = result; state.error = null; }
+        } catch (failure) { if (expanded.get(session.id) === state) state.error = failure.name === 'AbortError' ? 'Run history refresh timed out.' : failure.message; }
+      }));
+      if (query === params.toString()) renderRows();
+    } catch (failure) { showError(failure.name === 'AbortError' ? 'Refresh timed out. Use Refresh now to retry.' : failure.message); if (!initialized) status.textContent = 'Sessions could not be loaded.'; }
+    finally { clearTimeout(timeout); busy = false; table.setAttribute('aria-busy', 'false'); if (pending && !document.hidden) refresh(); }
+  }
+  function change(key, selected, resetPage = true) {
+    if (selected) params.set(key, selected); else params.delete(key);
+    if (resetPage) params.set('page', '1');
+    saveUrl(); restoreControls(); refresh();
+  }
+  form.addEventListener('submit', event => {
+    event.preventDefault();
+    const next = new URLSearchParams();
+    for (const [key, entered] of new FormData(form)) {
+      if (!entered) continue;
+      next.set(key, ['from', 'to'].includes(key) ? new Date(entered).toISOString() : entered);
+    }
+    for (const key of ['sort', 'direction', 'page_size']) if (params.has(key)) next.set(key, params.get(key));
+    next.set('page', '1');
+    // Clear via a key snapshot: deleting while iterating URLSearchParams skips adjacent keys.
+    for (const key of Array.from(params.keys())) params.delete(key);
+    next.forEach((entry, key) => params.set(key, entry)); saveUrl(); refresh();
+  });
+  document.querySelector('#clear-filters').addEventListener('click', () => { for (const key of Array.from(params.keys())) params.delete(key); form.reset(); restoreControls(); saveUrl(); refresh(); });
+  document.querySelector('#sort').addEventListener('change', event => change('sort', event.target.value));
+  document.querySelector('#direction').addEventListener('change', event => change('direction', event.target.value));
+  document.querySelector('#page-size').addEventListener('change', event => change('page_size', event.target.value));
+  document.querySelector('#previous-page').addEventListener('click', () => change('page', String(page() - 1), false));
+  document.querySelector('#next-page').addEventListener('click', () => change('page', String(page() + 1), false));
+  document.querySelectorAll('[data-sort]').forEach(button => button.addEventListener('click', () => {
+    params.set('direction', value('sort', 'latest_activity') === button.dataset.sort && value('direction', 'desc') === 'desc' ? 'asc' : 'desc');
+    change('sort', button.dataset.sort);
+  }));
+  document.querySelector('#refresh').addEventListener('click', () => { loadOptions(); refresh(); });
+  document.addEventListener('visibilitychange', () => { if (!document.hidden && document.querySelector('#auto-refresh').checked) refresh(); });
+  window.addEventListener('popstate', () => { for (const key of Array.from(params.keys())) params.delete(key); new URLSearchParams(location.search).forEach((entry, key) => params.set(key, entry)); restoreControls(); refresh(); });
+  setInterval(() => { if (!document.hidden && document.querySelector('#auto-refresh').checked) refresh(); }, 10000);
+  restoreControls(); loadOptions(); refresh();
+})();

data/lib/inferno_session_browser/configuration.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+module InfernoSessionBrowser
+  class Configuration
+    attr_accessor :mount_path, :fhir_url_input_names
+
+    def initialize
+      @mount_path = '/sessions'
+      @fhir_url_input_names = ['url']
+    end
+
+    def snapshot
+      path = mount_path.to_s.sub(%r{/+\z}, '')
+      unless path.match?(%r{\A/(?:[A-Za-z0-9_-]+/)*[A-Za-z0-9_-]+\z})
+        raise ArgumentError, 'mount_path must be a non-root path containing letters, numbers, underscores, or hyphens'
+      end
+      names = Array(fhir_url_input_names).map { |name| name.to_s.downcase }.uniq
+      raise ArgumentError, 'fhir_url_input_names must contain at least one nonempty input name' if names.empty? || names.any?(&:empty?)
+
+      copy = dup
+      copy.mount_path = path.freeze
+      copy.fhir_url_input_names = names.map(&:freeze).freeze
+      copy.freeze
+    end
+  end
+end

data/lib/inferno_session_browser/middleware.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+require 'rack'
+require 'erb'
+require 'json'
+require_relative 'query'
+
+module InfernoSessionBrowser
+  class Middleware
+    ASSETS = { 'app.js' => 'application/javascript; charset=utf-8', 'app.css' => 'text/css; charset=utf-8' }.freeze
+
+    def initialize(app, configuration:, base_path: '', db: nil, registry: Registry.new)
+      @app, @configuration, @db, @registry = app, configuration, db, registry
+      @base_path = base_path.to_s.split('/').reject(&:empty?).map { |part| "/#{part}" }.join
+      @mount_path = "#{@base_path}#{configuration.mount_path}"
+      @template = ERB.new(File.read(File.join(__dir__, 'templates/index.html.erb')))
+      @assets = ASSETS.to_h { |name, type| [name, [type, File.binread(File.join(__dir__, 'assets', name)).freeze]] }.freeze
+    end
+
+    def call(env)
+      path = env['PATH_INFO'].to_s
+      return @app.call(env) unless path == @mount_path || path == "#{@mount_path}/" || path.start_with?("#{@mount_path}/api/", "#{@mount_path}/assets/")
+      response = browser_response(path, env)
+      env['REQUEST_METHOD'] == 'HEAD' ? [response[0], response[1], []] : response
+    end
+
+    private
+
+    def browser_response(path, env)
+      return json(405, { error: 'Only GET and HEAD are supported' }, 'Allow' => 'GET, HEAD') unless %w[GET HEAD].include?(env['REQUEST_METHOD'])
+      dispatch(path, env)
+    rescue InvalidParameters, Rack::QueryParser::ParameterTypeError, Rack::QueryParser::InvalidParameterError, Rack::QueryParser::ParamsTooDeepError => e
+      json(400, { error: e.message })
+    rescue NotFound => e
+      json(404, { error: e.message })
+    rescue StandardError => e
+      # Host logging receives the class only, never SQL, session data, or URL credentials.
+      log_failure(e)
+      json(500, { error: 'Unable to load sessions. Please try again.' })
+    end
+
+    def log_failure(error)
+      return unless defined?(Inferno::Application)
+      Inferno::Application['logger']&.error("inferno_session_browser request failed: #{error.class}")
+    rescue StandardError
+      nil
+    end
+
+    def dispatch(path, env)
+      if path == @mount_path || path == "#{@mount_path}/"
+        return [200, { 'Content-Type' => 'text/html; charset=utf-8', 'Cache-Control' => 'no-store',
+                       'Content-Security-Policy' => "default-src 'self'; script-src 'self'; style-src 'self'; connect-src 'self'; object-src 'none'; base-uri 'none'",
+                       'X-Content-Type-Options' => 'nosniff' }, [@template.result_with_hash(mount_path: @mount_path, version: VERSION)]]
+      end
+      ASSETS.each_key do |name|
+        next unless path == "#{@mount_path}/assets/#{VERSION}/#{name}"
+        type, content = @assets.fetch(name)
+        return [200, { 'Content-Type' => type, 'Cache-Control' => 'public, max-age=31536000, immutable',
+                       'X-Content-Type-Options' => 'nosniff' }, [content]]
+      end
+      request = Rack::Request.new(env)
+      parameters = request.GET
+      case path
+      when "#{@mount_path}/api/sessions"
+        json(200, query.sessions(parameters))
+      when "#{@mount_path}/api/options"
+        raise InvalidParameters, 'Options endpoint does not accept parameters' unless parameters.empty?
+        json(200, query.options)
+      else
+        match = path.match(%r{\A#{Regexp.escape(@mount_path)}/api/sessions/([^/]+)/runs\z})
+        return json(404, { error: 'Browser route not found' }) unless match
+        session_id = Rack::Utils.unescape_path(match[1]).force_encoding(Encoding::UTF_8)
+        raise InvalidParameters, 'Invalid session ID encoding' unless session_id.valid_encoding?
+        json(200, query.runs(session_id, parameters))
+      end
+    end
+
+    def query
+      Query.new(db: @db || Inferno::Application['db.connection'], configuration: @configuration,
+                base_path: @base_path, registry: @registry)
+    end
+
+    def json(status, body, headers = {})
+      [status, { 'Content-Type' => 'application/json; charset=utf-8', 'Cache-Control' => 'no-store',
+                 'X-Content-Type-Options' => 'nosniff' }.merge(headers), [JSON.generate(body)]]
+    end
+  end
+end

data/lib/inferno_session_browser/parameters.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+require 'time'
+
+module InfernoSessionBrowser
+  class InvalidParameters < StandardError; end
+  class NotFound < StandardError; end
+
+  class Parameters
+    STATES = %w[never_run queued running waiting cancelling idle].freeze
+    SORTS = %w[latest_activity created_at suite].freeze
+    KEYS = %w[page page_size q suite_id suite_options fhir_url state date_field from to sort direction].freeze
+    attr_reader :page, :page_size, :filters, :sort, :direction
+
+    def initialize(raw, history: false)
+      unknown = raw.keys - (history ? %w[page page_size] : KEYS)
+      raise InvalidParameters, "Unknown parameter: #{unknown.first}" unless unknown.empty?
+
+      @page = integer(raw.fetch('page', '1'), 'page')
+      @page_size = integer(raw.fetch('page_size', '25'), 'page_size')
+      raise InvalidParameters, 'page_size must be 25, 50, or 100' unless [25, 50, 100].include?(@page_size)
+      @sort = scalar(raw.fetch('sort', 'latest_activity'), 'sort')
+      @direction = scalar(raw.fetch('direction', 'desc'), 'direction')
+      raise InvalidParameters, 'Invalid sort field' unless SORTS.include?(@sort)
+      raise InvalidParameters, 'direction must be asc or desc' unless %w[asc desc].include?(@direction)
+
+      @filters = raw.slice('q', 'suite_id', 'fhir_url', 'state', 'date_field').transform_values do |value|
+        scalar(value, 'filter')
+      end
+      @filters.reject! { |_key, value| value.empty? }
+      state = @filters['state']
+      raise InvalidParameters, 'Invalid run state' if state && !STATES.include?(state)
+      date_field = @filters.fetch('date_field', 'created_at')
+      raise InvalidParameters, 'date_field must be created_at or latest_activity' unless %w[created_at latest_activity].include?(date_field)
+      @filters['date_field'] = date_field
+      %w[from to].each { |key| @filters[key] = timestamp(raw[key], key) if raw[key] && raw[key] != '' }
+      if @filters['from'] && @filters['to'] && @filters['from'] >= @filters['to']
+        raise InvalidParameters, 'from must be earlier than to'
+      end
+      options = raw.fetch('suite_options', {})
+      raise InvalidParameters, 'suite_options must be an object of option IDs and values' unless options.is_a?(Hash)
+      @filters['suite_options'] = options.each_with_object({}) do |(key, value), selected|
+        raise InvalidParameters, 'Invalid suite option ID' unless key.match?(/\A[a-zA-Z0-9_-]+\z/)
+        selected[key] = scalar(value, 'suite option') unless value == ''
+      end
+    end
+
+    def offset
+      (page - 1) * page_size
+    end
+
+    def metadata(total)
+      { page: page, page_size: page_size, total: total }
+    end
+
+    private
+
+    def scalar(value, name)
+      raise InvalidParameters, "#{name} must be a string" unless value.is_a?(String)
+      raise InvalidParameters, "#{name} is too long" if value.length > 2048
+      value
+    end
+
+    def integer(value, name)
+      text = scalar(value, name)
+      raise InvalidParameters, "#{name} must be a positive integer" unless text.match?(/\A[1-9]\d{0,8}\z/)
+      text.to_i
+    end
+
+    def timestamp(value, name)
+      text = scalar(value, name)
+      unless text.match?(/(?:Z|[+-]\d{2}:\d{2})\z/)
+        raise InvalidParameters, "#{name} must be an ISO 8601 timestamp with a timezone"
+      end
+      Time.iso8601(text).utc
+    rescue ArgumentError
+      raise InvalidParameters, "#{name} must be an ISO 8601 timestamp with a timezone"
+    end
+  end
+end