rdbr 0.1.0

data/lib/rdbr/web/filter_presentation_helpers.rb

@@ -0,0 +1,44 @@
+module RDBr
+  module Web
+    module FilterPresentationHelpers
+      TEMPORAL_TYPES = %i[date time timestamp timestamptz timetz].freeze
+
+      def filter_description(entry)
+        value, column = filter_chip_parts(entry)
+        "#{column}: #{value}"
+      end
+
+      def filter_chip_parts(entry)
+        operator = entry.fetch(:operator).to_s.tr('_', ' ')
+        value = entry.fetch(:value)
+        return [ truthy?(value) ? 'NULL' : 'NOT NULL', entry.fetch(:column) ] if operator == 'is null'
+
+        metadata = @relation&.column(entry.fetch(:column))
+        related = filter_related_value(entry)
+        column_name = metadata ? display_column_name(metadata) : entry.fetch(:column)
+        column = operator == 'eq' ? column_name : "#{column_name} #{operator}"
+        [ display_text(related ? related.label : value, limit: 80), column ]
+      end
+
+      def filter_related_value(entry)
+        return unless entry.fetch(:operator).to_s == 'eq'
+
+        metadata = @relation&.column(entry.fetch(:column))
+        related_value_for(metadata, entry.fetch(:value)) if metadata
+      end
+
+      def temporal_column?(column)
+        TEMPORAL_TYPES.include?(column.logical_type.to_s.to_sym)
+      end
+
+      def render_temporal_filter(column, value)
+        rendered = render_column_value(column, value, compact: true)
+        name = Rack::Utils.escape_html(column.name)
+        raw_value = Rack::Utils.escape_html(value.to_s)
+        '<button class="temporal-value-filter" type="button" ' \
+          "data-date-filter-column=\"#{name}\" data-date-filter-value=\"#{raw_value}\" " \
+          "title=\"Filter #{name} by date range\">#{rendered}</button>"
+      end
+    end
+  end
+end

data/lib/rdbr/web/helpers.rb

@@ -0,0 +1,42 @@
+require_relative 'array_value_helpers'
+require_relative 'binary_value_helpers'
+require_relative 'deferred_column_value_helpers'
+require_relative 'deferred_value_helpers'
+require_relative 'document_value_helpers'
+require_relative 'filter_presentation_helpers'
+require_relative 'identifier_value_helpers'
+require_relative 'navigation_helpers'
+require_relative 'presentation_helpers'
+require_relative 'record_value_helpers'
+require_relative 'related_value_helpers'
+require_relative 'range_value_helpers'
+require_relative 'search_value_helpers'
+require_relative 'spatial_value_helpers'
+require_relative 'vector_value_helpers'
+
+module RDBr
+  module Web
+    module Helpers
+      include ArrayValueHelpers
+      include BinaryValueHelpers
+      include DeferredColumnValueHelpers
+      include DeferredValueHelpers
+      include DocumentValueHelpers
+      include FilterPresentationHelpers
+      include IdentifierValueHelpers
+      include NavigationHelpers
+      include PresentationHelpers
+      include RecordValueHelpers
+      include RelatedValueHelpers
+      include RangeValueHelpers
+      include SearchValueHelpers
+      include SpatialValueHelpers
+      include VectorValueHelpers
+
+      def versioned_asset_url(path)
+        filename = File.join(settings.public_folder, path.delete_prefix('/'))
+        "#{path}?v=#{File.mtime(filename).to_i}"
+      end
+    end
+  end
+end

data/lib/rdbr/web/identifier_value_helpers.rb

@@ -0,0 +1,20 @@
+module RDBr
+  module Web
+    module IdentifierValueHelpers
+      IDENTIFIER_TYPES = %w[uuid uniqueidentifier].freeze
+      IDENTIFIER_NAMES = %w[uuid uid guid].freeze
+
+      def identifier_column?(column)
+        type = column.logical_type.to_s.downcase
+        sql_type = column.sql_type.to_s.downcase
+        name_parts = column.name.gsub(/([a-z\d])([A-Z])/, '\\1_\\2').downcase.split(/[^a-z0-9]+/)
+        IDENTIFIER_TYPES.include?(type) || sql_type.match?(/\b(?:uuid|uniqueidentifier)\b/) ||
+          name_parts.any?{|part| IDENTIFIER_NAMES.include?(part) }
+      end
+
+      def render_identifier_controls(value)
+        render_deferred_value(value, qualifier: 'identifier')
+      end
+    end
+  end
+end

data/lib/rdbr/web/json_page_stream.rb

@@ -0,0 +1,30 @@
+module RDBr
+  module Web
+    class JsonPageStream
+      def initialize(page)
+        @attributes = page.to_h
+      end
+
+      def each(&writer)
+        writer.call('{')
+        @attributes.each_with_index do |(key, value), index|
+          writer.call(',') unless index.zero?
+          writer.call("#{JSON.generate(key)}:")
+          key == :rows ? yield_rows(value, &writer) : writer.call(JSON.generate(value))
+        end
+        writer.call('}')
+      end
+
+      private
+
+      def yield_rows(rows)
+        yield '['
+        rows.each_with_index do |row, index|
+          yield ',' unless index.zero?
+          yield JSON.generate(row)
+        end
+        yield ']'
+      end
+    end
+  end
+end

data/lib/rdbr/web/navigation_helpers.rb

@@ -0,0 +1,115 @@
+module RDBr
+  module Web
+    module NavigationHelpers
+      def relation_url(namespace, relation, extra = {})
+        query_url('/data', { namespace: namespace, relation: relation }.merge(extra))
+      end
+
+      def record_url(namespace, relation, row, primary_key)
+        key = primary_key.columns.to_h{|column| [ column, row[column]] }
+        query_url('/record', namespace: namespace, relation: relation, key: key)
+      end
+
+      def group_url(namespace, relation, column)
+        query_url(
+          '/group', namespace: namespace, relation: relation, column: column,
+          filter: request.params['filter'], search: params['search'], per_page: params['per_page']
+        )
+      end
+
+      def page_url(number)
+        query_url(request.path, request.params.merge('page' => number))
+      end
+
+      def sort_url(column)
+        parameters = mutable_request_params
+        current = parameters['sort'].to_s
+        next_sort = current == column ? "-#{column}" : column
+        query_url(request.path, parameters.merge('sort' => next_sort, 'page' => 1))
+      end
+
+      def sort_indicator(column)
+        return ' ↑' if params['sort'] == column
+        return ' ↓' if params['sort'] == "-#{column}"
+
+        ''
+      end
+
+      def filter_operators(column)
+        settings.query_service.filter_operators(column).map(&:to_s)
+      end
+
+      def filter_entries
+        requested_filter_hash.flat_map do |column, conditions|
+          conditions.to_h.map{|operator, value| { column: column, operator: operator, value: value } }
+        end
+      end
+
+      def fixed_filter_columns
+        requested_filter_hash.filter_map do |column, conditions|
+          condition = conditions.to_h
+          operator, value = condition.first
+          column if condition.length == 1 && (operator == 'eq' || (operator == 'is_null' && truthy?(value)))
+        end
+      end
+
+      def add_filter_url(column, value)
+        parameters = mutable_request_params
+        filters = requested_filter_hash
+        filters[column.name] = value.nil? ? { 'is_null' => true } : { 'eq' => value }
+        parameters.merge!('filter' => filters, 'page' => 1)
+        query_url('/data', parameters)
+      end
+
+      def remove_filter_url(column, operator)
+        parameters = mutable_request_params
+        filters = requested_filter_hash
+        filters.fetch(column, {}).delete(operator)
+        filters.delete(column) if filters.fetch(column, {}).empty?
+        parameters.merge!('filter' => filters, 'page' => 1)
+        query_url('/data', parameters)
+      end
+
+      def remove_search_url
+        parameters = mutable_request_params
+        parameters.delete('search')
+        query_url('/data', parameters.merge('page' => 1))
+      end
+
+      def clear_filters_url
+        parameters = mutable_request_params
+        parameters.delete('filter')
+        parameters.delete('search')
+        query_url('/data', parameters.merge('page' => 1))
+      end
+
+      def query_url(path, parameters)
+        query = Rack::Utils.build_nested_query(parameters.reject{|_key, value| value.nil? || value == '' })
+        query.empty? ? path : "#{path}?#{query}"
+      end
+
+      private
+
+      def requested_filter_hash
+        deep_hash(request.params.fetch('filter', {}))
+      end
+
+      def mutable_request_params
+        deep_hash(request.params).tap do |parameters|
+          %w[filter_column filter_operator filter_value].each{|name| parameters.delete(name) }
+        end
+      end
+
+      def deep_hash(value)
+        return value.to_h.to_h{|key, item| [ key.to_s, deep_hash(item) ] } if value.respond_to?(:to_h)
+        return value.map{|item| deep_hash(item) } if value.is_a?(Array)
+
+        value
+      end
+
+      def truthy?(value)
+        [ true, 'true', '1', 1 ].include?(value)
+      end
+    end
+  end
+end

data/lib/rdbr/web/presentation_helpers.rb

@@ -0,0 +1,114 @@
+module RDBr
+  module Web
+    module PresentationHelpers
+      def render_table_value(relation, column, value)
+        return render_temporal_filter(column, value) if temporal_column?(column) && !value.nil?
+
+        related = related_value_for(column, value)
+        deferred = deferred_table_value(column, value) unless related
+        return deferred if deferred
+
+        rendered = related ? render_related_value(related) : render_column_value(column, value, compact: true)
+        return rendered unless filterable_column?(relation, column) && directly_filterable?(column, value)
+
+        title = "Filter #{column.name} by this value"
+        href = Rack::Utils.escape_html(add_filter_url(column, value))
+        %(<a class="value-filter" href="#{href}" title="#{Rack::Utils.escape_html(title)}">#{rendered}</a>)
+      end
+
+      def filterable_column?(relation, column)
+        !relation.uniquely_constrained_column?(column.name)
+      end
+
+      def record_label(relation, row, exclude: [])
+        label = record_identity(relation).label(row, exclude: exclude)
+        display_text(label, limit: 100)
+      end
+
+      def foreign_record_url(namespace, relation, column, row)
+        related = related_value_for(column, row[column.name])
+        return related_value_url(related) if related
+
+        foreign_key = relation.foreign_keys.find{|key| key.columns.include?(column.name) }
+        return unless foreign_key
+
+        target_namespace, target = foreign_target(namespace, foreign_key)
+        return unless navigable_foreign_key?(target, foreign_key)
+
+        key = foreign_key.referenced_columns.zip(foreign_key.columns.map{|name| row[name] }).to_h
+        return if key.values.any?(&:nil?)
+
+        record_url(target_namespace.name, target.name, key, target.primary_key)
+      end
+
+      def render_value(value, compact: false)
+        return '<span class="null">NULL</span>' if value.nil?
+        return render_structured(value, compact: compact) if value.is_a?(Array) || value.is_a?(Hash)
+
+        text = display_value(value)
+        text = "#{text.slice(0, 160)}…" if compact && text.length > 160
+        css_class = text.empty? ? 'empty' : value_class(value)
+        %(<span class="#{css_class}">#{Rack::Utils.escape_html(text)}</span>)
+      end
+
+      private
+
+      def deferred_table_value(column, value)
+        return if value.nil?
+
+        deferred = render_deferred_column_value(column, value)
+        return deferred if deferred
+
+        render_identifier_controls(value) if identifier_column?(column)
+      end
+
+      def record_identity(relation)
+        @record_identities ||= {}.compare_by_identity
+        @record_identities[relation] ||= RDBr::Presentation::RecordIdentity.new(relation)
+      end
+
+      def display_value(value) = case value; when Time, DateTime then value.strftime('%F %T'); else value.to_s end
+
+      def foreign_target(namespace, foreign_key)
+        target_namespace = settings.catalog.namespace(foreign_key.referenced_namespace || namespace.name)
+        [ target_namespace, target_namespace&.relation(foreign_key.referenced_relation) ]
+      end
+
+      def navigable_foreign_key?(target, foreign_key)
+        target&.primary_key && target.primary_key.columns.sort == foreign_key.referenced_columns.sort
+      end
+
+      def directly_filterable?(column, value)
+        return true if value.nil?
+        return false if value.is_a?(Array) || value.is_a?(Hash)
+
+        !%i[bytea json xml].include?(column.logical_type.to_s.to_sym)
+      end
+
+      def display_text(value, limit:)
+        text = if value.is_a?(Array) || value.is_a?(Hash)
+                 JSON.generate(value)
+               elsif value.nil?
+                 'NULL'
+               else
+                 value.to_s
+               end
+        text.length > limit ? "#{text.slice(0, limit)}…" : text
+      end
+
+      def render_structured(value, compact:)
+        json = compact ? JSON.generate(value) : JSON.pretty_generate(value)
+        json = "#{json.slice(0, 160)}…" if compact && json.length > 160
+        %(<code class="structured">#{Rack::Utils.escape_html(json)}</code>)
+      end
+
+      def value_class(value)
+        case value
+        when true, false then 'boolean'
+        when Numeric then 'number'
+        else 'text'
+        end
+      end
+    end
+  end
+end

data/lib/rdbr/web/range_value_helpers.rb

@@ -0,0 +1,86 @@
+module RDBr
+  module Web
+    module RangeValueHelpers
+      FALLBACK_PREVIEW_LENGTH = 160
+      RANGE_LABELS = {
+        'daterange' => 'Date range', 'int4range' => 'Integer range', 'int8range' => 'Integer range',
+        'numrange' => 'Numeric range', 'tsrange' => 'Timestamp range',
+        'tstzrange' => 'Timestamp with time zone range'
+      }.freeze
+
+      def range_column?(column)
+        range_type(column).match?(/(?:multi)?range\z/i)
+      end
+
+      def render_range_value(column, value)
+        text = range_text(value)
+        render_deferred_value(text, qualifier: 'range', summary: range_summary(column, value, text))
+      end
+
+      def deferred_unfamiliar_value?(column, value)
+        unfamiliar_column?(column) && fallback_text(value).length > FALLBACK_PREVIEW_LENGTH
+      end
+
+      def render_unfamiliar_value(column, value)
+        text = fallback_text(value)
+        type = column.sql_type.to_s.empty? ? column.logical_type : column.sql_type
+        render_deferred_value(
+          text, qualifier: 'unfamiliar', summary: "#{type} · #{text.length} characters"
+        )
+      end
+
+      private
+
+      def range_type(column)
+        logical_type = column.logical_type.to_s
+        logical_type.end_with?('range') ? logical_type : column.sql_type.to_s
+      end
+
+      def range_text(value)
+        value.is_a?(Array) ? JSON.pretty_generate(value) : value.to_s
+      end
+
+      def range_summary(column, value, text)
+        type = range_type(column).downcase
+        base_type = type.delete_suffix('multirange')
+        label = RANGE_LABELS["#{base_type}range"] || humanize_range_type(type)
+        return "#{label} · empty" if text.casecmp('empty').zero?
+        return label unless type.end_with?('multirange')
+
+        count = value.is_a?(Array) ? value.length : multirange_count(text)
+        "#{label.sub(/ range\z/, ' multirange')} · #{count} #{count == 1 ? 'range' : 'ranges'}"
+      end
+
+      def humanize_range_type(type)
+        type.sub(/multirange\z/i, '').sub(/range\z/i, '').tr('_', ' ').strip.capitalize.then do |name|
+          name.empty? ? 'Range' : "#{name} range"
+        end
+      end
+
+      def multirange_count(text)
+        quoted = false
+        escaped = false
+        text.each_char.count do |character|
+          if escaped
+            escaped = false
+          elsif character == '\\'
+            escaped = true
+          elsif character == '"'
+            quoted = !quoted
+          end
+          !quoted && [ '[', '(' ].include?(character)
+        end
+      end
+
+      def unfamiliar_column?(column)
+        type = column.logical_type.to_s.to_sym
+        known = Query::TypeSupport::TYPE_GROUPS.values.flatten
+        !known.include?(type) && !%i[json jsonb].include?(type)
+      end
+
+      def fallback_text(value)
+        value.is_a?(Array) || value.is_a?(Hash) ? JSON.pretty_generate(value) : value.to_s
+      end
+    end
+  end
+end

data/lib/rdbr/web/record_value_helpers.rb

@@ -0,0 +1,90 @@
+module RDBr
+  module Web
+    module RecordValueHelpers
+      PREVIEW_LENGTH = 320
+      JSON_DECODE_DEPTH = 3
+      TIMESTAMP_TYPES = %i[timestamp timestamptz].freeze
+      JSON_TYPES = %i[json jsonb].freeze
+
+      def render_record_value(column, value)
+        deferred_value = render_deferred_record_value(column, value) unless value.nil?
+        return deferred_value if deferred_value
+        return render_identifier_controls(value) if identifier_column?(column) && !value.nil?
+        return render_column_value(column, value) unless long_text_value?(column, value)
+
+        text = value.to_s
+        dialog_id = "full-value-#{column.ordinal || safe_dom_name(column.name)}"
+        render_deferred_dialog(
+          dialog_id: dialog_id, column_name: column.name, text: text,
+          trigger: preview_button(dialog_id, text)
+        )
+      end
+
+      def render_column_value(column, value, compact: false)
+        render_value(normalized_column_value(column, value), compact: compact)
+      end
+
+      private
+
+      def render_deferred_record_value(column, value)
+        return render_json_value(column, value) if JSON_TYPES.include?(column.logical_type.to_s.to_sym)
+
+        render_deferred_column_value(column, value)
+      end
+
+      def render_json_value(column, value)
+        dialog_id = "full-value-#{column.ordinal || safe_dom_name(column.name)}"
+        json = pretty_json(value)
+        render_deferred_dialog(
+          dialog_id: dialog_id, column_name: column.name, text: json,
+          trigger: json_button(dialog_id), content_class: 'structured'
+        )
+      end
+
+      def pretty_json(value)
+        JSON.pretty_generate(normalized_json(value))
+      end
+
+      def normalized_json(value)
+        decoded = value.is_a?(String) ? JSON.parse(value) : value
+        (JSON_DECODE_DEPTH - 1).times do
+          break unless decoded.is_a?(String)
+          candidate = decoded.strip
+          break unless candidate.start_with?('{', '[')
+
+          decoded = JSON.parse(candidate)
+        end
+        decoded
+      rescue JSON::ParserError
+        value
+      end
+
+      def json_button(dialog_id)
+        id = Rack::Utils.escape_html(dialog_id)
+        attributes = %(data-open-dialog="#{id}" aria-haspopup="dialog" aria-controls="#{id}")
+        %(<button class="json-preview" type="button" #{attributes}>Show JSON</button>)
+      end
+
+      def normalized_column_value(column, value)
+        return value unless TIMESTAMP_TYPES.include?(column.logical_type.to_s.to_sym) && value.is_a?(String)
+
+        Time.iso8601(value)
+      rescue ArgumentError
+        value
+      end
+
+      def long_text_value?(column, value)
+        Query::TypeSupport::TYPE_GROUPS.fetch(:text).include?(column.logical_type.to_s.to_sym) &&
+          value.to_s.length > PREVIEW_LENGTH
+      end
+
+      def preview_button(dialog_id, text)
+        id = Rack::Utils.escape_html(dialog_id)
+        preview = Rack::Utils.escape_html("#{text.slice(0, PREVIEW_LENGTH)}…")
+        attributes = %(data-open-dialog="#{id}" aria-haspopup="dialog" aria-controls="#{id}")
+        %(<button class="text-preview" type="button" #{attributes}>) \
+          "<span>#{preview}</span><small>Show full text</small></button>"
+      end
+    end
+  end
+end

data/lib/rdbr/web/related_value_helpers.rb

@@ -0,0 +1,99 @@
+module RDBr
+  module Web
+    module RelatedValueHelpers
+      RelatedValue = Data.define(
+        :column, :raw_value, :label, :namespace, :relation, :row, :key, :inferred
+      )
+
+      def load_related_values(namespace, relation, rows)
+        settings.catalog.outgoing_relationships(namespace, relation).each_with_object({}) do |relationship, values|
+          load_relationship_values(relationship, rows, values)
+        end
+      end
+
+      def related_value_for(column, value)
+        @related_values&.fetch(related_value_key(column.name, value), nil)
+      end
+
+      def display_column_name(column)
+        return column.name unless relationship_column?(column)
+
+        humanize_identifier(column.name.sub(/_id\z/i, '').sub(/Id\z/, ''))
+      end
+
+      def related_value_url(value)
+        primary_key = value.relation.primary_key
+        if primary_key&.columns&.sort == value.key.keys.sort
+          return record_url(value.namespace.name, value.relation.name, value.key, primary_key)
+        end
+
+        relation_url(value.namespace.name, value.relation.name, filter: equality_filters(value.key))
+      end
+
+      def render_related_value(value, compact: true)
+        title = "#{value.column.name}: #{value.raw_value}"
+        text = display_text(value.label, limit: compact ? 160 : 500)
+        %(<span class="related-value" title="#{Rack::Utils.escape_html(title)}">) \
+          "#{Rack::Utils.escape_html(text)}</span>"
+      end
+
+      private
+
+      def load_relationship_values(relationship, rows, values)
+        foreign_key, targets = relationship_targets(relationship, rows)
+        return unless foreign_key
+
+        referenced_column = foreign_key.referenced_columns.first
+        targets.each do |target|
+          add_related_value(relationship, foreign_key, referenced_column, target, values)
+        end
+      end
+
+      def relationship_targets(relationship, rows)
+        foreign_key = relationship.foreign_key
+        return unless foreign_key.columns.length == 1 && foreign_key.referenced_columns.length == 1
+
+        raw_values = rows.filter_map{|row| row[foreign_key.columns.first] }.uniq
+        return if raw_values.empty?
+
+        keys = raw_values.map{|value| { foreign_key.referenced_columns.first => value } }
+        targets = settings.query_service.lookup(
+          namespace: relationship.target_namespace.name, relation: relationship.target_relation.name, keys: keys
+        )
+        [ foreign_key, targets ]
+      rescue Query::ExecutionError, Query::InvalidQueryError
+        nil
+      end
+
+      def add_related_value(relationship, foreign_key, referenced_column, target, values)
+        raw_value = target[referenced_column]
+        return if raw_value.nil?
+
+        local_column = foreign_key.columns.first
+        entry = RelatedValue.new(
+          column: @relation.column(local_column), raw_value: raw_value,
+          label: record_identity(relationship.target_relation).label(target),
+          namespace: relationship.target_namespace, relation: relationship.target_relation,
+          row: target, key: { referenced_column => raw_value }, inferred: relationship.inferred
+        )
+        values[related_value_key(local_column, raw_value)] = entry
+      end
+
+      def related_value_key(column, value)
+        [ column.to_s, value.to_s ]
+      end
+
+      def relationship_column?(column)
+        return false unless @namespace && @relation
+
+        settings.catalog.outgoing_relationships(@namespace, @relation).any? do |relationship|
+          relationship.foreign_key.columns == [ column.name ]
+        end
+      end
+
+      def humanize_identifier(value)
+        value.gsub(/([a-z\d])([A-Z])/, '\1 \2').tr('_-', '  ').split.map(&:capitalize).join(' ')
+      end
+    end
+  end
+end