rdbr 0.1.0

data/lib/rdbr/web/application.rb

@@ -0,0 +1,234 @@
+module RDBr
+  module Web
+    class Application < Sinatra::Base
+      include RelationshipLoader
+
+      ROOT = File.expand_path('../../..', __dir__).freeze
+      PAGE_SIZES = [ 10, 25, 50, 100 ].freeze
+
+      set :public_folder, File.join(ROOT, 'app/public')
+      set :views, File.join(ROOT, 'app/views')
+      set :static, true
+      set :catalog, nil
+      set :query_service, nil
+      set :access_policy, Access::ReadOnly.new
+      helpers Helpers
+
+      before do
+        halt 405, 'Read-only interface' unless settings.access_policy.allow_http_method?(request.request_method)
+      end
+
+      get '/' do
+        haml :index
+      end
+
+      get '/data' do
+        require_query_service!
+        @namespace, @relation = find_relation!
+        redirect canonical_filter_url if params['filter_column'].to_s != ''
+
+        @filters = requested_filters
+        @column_preferences = column_preferences_for(@relation)
+        @available_columns = @column_preferences.ordered_columns
+        @visible_columns = @column_preferences.visible_columns
+        @page = settings.query_service.page(
+          namespace: @namespace.name,
+          relation: @relation.name,
+          page: params.fetch('page', 1),
+          per_page: preferred_page_size,
+          sort: params['sort'],
+          search: params['search'],
+          filters: @filters,
+          include_total: true
+        )
+        redirect page_url(@page.total_pages) if @page.page > @page.total_pages
+        @related_values = load_related_values(@namespace, @relation, @page.rows + filter_value_rows)
+        haml :data
+      rescue Query::InvalidQueryError => e
+        halt 400, e.message
+      rescue Query::ExecutionError => e
+        halt query_error_status(e), e.message
+      end
+
+      get '/record' do
+        require_query_service!
+        @namespace, @relation = find_relation!
+        @record = settings.query_service.record(
+          namespace: @namespace.name, relation: @relation.name, key: params.fetch('key', {})
+        )
+        halt 404, 'Record not found' unless @record
+
+        @related_values = load_related_values(@namespace, @relation, [ @record ])
+        @outgoing_relationships = outgoing_relationships
+        @through_relationships = through_relationships
+        @incoming_relationships = incoming_relationships
+        haml :record
+      rescue Query::InvalidQueryError => e
+        halt 400, e.message
+      rescue Query::ExecutionError => e
+        halt query_error_status(e), e.message
+      end
+
+      get '/group' do
+        require_query_service!
+        @namespace, @relation = find_relation!
+        @column = @relation.column(required_parameter('column'))
+        halt 404, 'Unknown column' unless @column
+
+        @filters = requested_filters
+        @page = settings.query_service.group(
+          namespace: @namespace.name, relation: @relation.name, column: @column.name,
+          page: params.fetch('page', 1), per_page: preferred_page_size,
+          search: params['search'], filters: @filters
+        )
+        group_rows = @page.rows.map{|row| { @column.name => row['value'] } }
+        @related_values = load_related_values(@namespace, @relation, group_rows + filter_value_rows)
+        haml :group
+      rescue Query::InvalidQueryError => e
+        halt 400, e.message
+      rescue Query::ExecutionError => e
+        halt query_error_status(e), e.message
+      end
+
+      get '/catalog.json' do
+        halt 404 unless settings.catalog
+
+        content_type :json
+        JSON.generate(Catalog::Serializer.call(settings.catalog))
+      end
+
+      get '/database-graph.json' do
+        halt 404 unless settings.catalog
+
+        content_type :json
+        DatabaseGraph.call(settings.catalog)
+      end
+
+      get '/data.json' do
+        halt 404 unless settings.query_service
+
+        page = settings.query_service.page(
+          namespace: required_parameter('namespace'),
+          relation: required_parameter('relation'),
+          page: params.fetch('page', 1),
+          per_page: params.fetch('per_page', Query::Postgresql::DEFAULT_PAGE_SIZE),
+          sort: params['sort'],
+          search: params['search'],
+          filters: params.fetch('filter', {}),
+          include_total: true
+        )
+        content_type :json
+        body JsonPageStream.new(page)
+      rescue Query::InvalidQueryError => e
+        halt 400, e.message
+      rescue Query::RelationNotFoundError
+        halt 404, 'Unknown namespace or relation'
+      rescue Query::ExecutionError => e
+        halt query_error_status(e), e.message
+      end
+
+      get '/count.json' do
+        require_query_service!
+        namespace, relation = find_relation!
+        page = settings.query_service.page(
+          namespace: namespace.name, relation: relation.name,
+          page: 1, per_page: 1, filters: {}, include_total: true
+        )
+        content_type :json
+        JSON.generate(total_count: page.total_count)
+      rescue Query::InvalidQueryError => e
+        halt 400, e.message
+      rescue Query::ExecutionError => e
+        halt query_error_status(e), e.message
+      end
+
+      get '/health' do
+        content_type :json
+        JSON.generate(
+          status: 'ok',
+          version: RDBr::VERSION,
+          access_mode: settings.access_policy.mode,
+          connected: !settings.catalog.nil?,
+          queryable: !settings.query_service.nil?
+        )
+      end
+
+      private
+
+      def query_error_status(error)
+        return 403 if error.is_a?(Query::AccessDeniedError)
+        return 504 if error.is_a?(Query::TimeoutError)
+
+        503
+      end
+
+      def column_preferences_for(relation)
+        preference = ColumnPreferences.new(
+          database: settings.catalog, namespace: @namespace, relation: relation,
+          fixed_columns: fixed_filter_columns
+        )
+        ColumnPreferences.new(
+          database: settings.catalog, namespace: @namespace, relation: relation,
+          fixed_columns: fixed_filter_columns, value: request.cookies[preference.cookie_name]
+        )
+      end
+
+      def require_query_service!
+        halt 404 unless settings.query_service
+      end
+
+      def find_relation!
+        namespace = settings.catalog&.namespace(required_parameter('namespace'))
+        relation = namespace&.relation(required_parameter('relation'))
+        halt 404, 'Unknown namespace or relation' unless relation
+
+        [ namespace, relation ]
+      end
+
+      def requested_filters
+        filters = params.fetch('filter', {}).to_h
+        column = params['filter_column'].to_s
+        return filters if column.empty?
+
+        operator = params.fetch('filter_operator', 'eq')
+        value = operator == 'is_null' ? true : params['filter_value']
+        filters.merge(column => { operator => value })
+      end
+
+      def canonical_filter_url
+        parameters = params.to_h.dup
+        parameters.delete('filter_column')
+        parameters.delete('filter_operator')
+        parameters.delete('filter_value')
+        parameters['filter'] = requested_filters
+        parameters['page'] = 1
+        query_url('/data', parameters)
+      end
+
+      def filter_value_rows
+        @filters.flat_map do |column, condition|
+          next [ { column.to_s => condition } ] unless condition.is_a?(Hash)
+
+          condition.to_h.filter_map do |operator, value|
+            { column.to_s => value } if operator.to_s == 'eq'
+          end
+        end
+      end
+
+      def required_parameter(name)
+        value = params[name]
+        halt 400, "Missing parameter: #{name}" if value.to_s.empty?
+
+        value
+      end
+
+      def preferred_page_size
+        explicit = params['per_page'].to_s
+        return explicit unless explicit.empty?
+
+        remembered = request.cookies['rdbr_page_size'].to_i
+        PAGE_SIZES.include?(remembered) ? remembered : Query::Postgresql::DEFAULT_PAGE_SIZE
+      end
+    end
+  end
+end

data/lib/rdbr/web/array_value_helpers.rb

@@ -0,0 +1,92 @@
+module RDBr
+  module Web
+    module ArrayValueHelpers
+      INLINE_ARRAY_ITEMS = 5
+      INLINE_ARRAY_CHARACTERS = 100
+
+      def array_column?(column)
+        logical_type = column.logical_type.to_s
+        logical_type.start_with?('_') || column.sql_type.to_s.match?(/\[\](?:\[\])*\z/)
+      end
+
+      def deferred_array_value?(column, value)
+        return false unless array_column?(column)
+
+        array_dimensions(value) > 1 || array_item_count(value) > INLINE_ARRAY_ITEMS ||
+          array_text(value).length > INLINE_ARRAY_CHARACTERS
+      end
+
+      def render_array_value(value)
+        render_deferred_value(array_text(value), qualifier: 'array', summary: array_summary(value))
+      end
+
+      private
+
+      def array_text(value)
+        value.is_a?(Array) ? JSON.pretty_generate(value) : value.to_s
+      end
+
+      def array_summary(value)
+        shape = rectangular_array_shape(value)
+        return "#{shape.join(' × ')} array" if shape&.length.to_i > 1
+
+        dimensions = array_dimensions(value)
+        return "#{dimensions}-dimensional array" if dimensions > 1
+
+        count = array_item_count(value)
+        "#{count} #{count == 1 ? 'item' : 'items'}"
+      end
+
+      def array_dimensions(value)
+        return array_depth(value) if value.is_a?(Array)
+
+        value.to_s.scan(/\{+/).map(&:length).max.to_i.clamp(1, Float::INFINITY)
+      end
+
+      def array_depth(value)
+        return 0 unless value.is_a?(Array)
+
+        1 + value.map{|entry| array_depth(entry) }.max.to_i
+      end
+
+      def array_item_count(value)
+        return value.sum{|entry| entry.is_a?(Array) ? array_item_count(entry) : 1 } if value.is_a?(Array)
+
+        array_literal_item_count(value.to_s)
+      end
+
+      def array_literal_item_count(text)
+        body = text.strip
+        return 0 if body.match?(/\A\{\s*\}\z/)
+
+        commas = 0
+        quoted = false
+        escaped = false
+        body.each_char do |character|
+          if escaped
+            escaped = false
+          elsif character == '\\'
+            escaped = true
+          elsif character == '"'
+            quoted = !quoted
+          elsif character == ',' && !quoted
+            commas += 1
+          end
+        end
+        commas + 1
+      end
+
+      def rectangular_array_shape(value)
+        return unless value.is_a?(Array)
+        return [ 0 ] if value.empty?
+        return [ value.length ] unless value.any?(Array)
+        return unless value.all?(Array)
+
+        child_shapes = value.map{|entry| rectangular_array_shape(entry) }
+        return unless child_shapes.uniq.length == 1
+
+        [ value.length, *child_shapes.first ]
+      end
+    end
+  end
+end

data/lib/rdbr/web/binary_value_helpers.rb

@@ -0,0 +1,51 @@
+require 'base64'
+
+module RDBr
+  module Web
+    module BinaryValueHelpers
+      BINARY_TYPES = %i[binary blob bytea image longblob mediumblob tinyblob varbinary].freeze
+
+      def binary_column?(column)
+        type = column.logical_type.to_s.to_sym
+        BINARY_TYPES.include?(type) || column.sql_type.to_s.match?(/(?:binary|blob|bytea)/i)
+      end
+
+      def deferred_binary_value?(column, value)
+        binary_column?(column) || encoded_binary_value?(value)
+      end
+
+      def render_binary_value(value)
+        payload, bytes = binary_payload(value)
+        summary = binary_summary(bytes)
+        render_deferred_value(payload, qualifier: 'binary', summary: summary)
+      end
+
+      private
+
+      def encoded_binary_value?(value)
+        value.is_a?(Hash) && value['encoding'] == 'base64' && value.key?('data')
+      end
+
+      def binary_summary(bytes)
+        return 'Base64' unless bytes
+
+        unit = bytes == 1 ? 'byte' : 'bytes'
+        "#{bytes} #{unit} · Base64"
+      end
+
+      def binary_payload(value)
+        return encoded_binary_payload(value) if encoded_binary_value?(value)
+
+        text = value.to_s.b
+        [ Base64.strict_encode64(text), text.bytesize ]
+      end
+
+      def encoded_binary_payload(value)
+        payload = value.fetch('data').to_s
+        [ payload, Base64.strict_decode64(payload).bytesize ]
+      rescue ArgumentError
+        [ payload, nil ]
+      end
+    end
+  end
+end

data/lib/rdbr/web/column_preferences.rb

@@ -0,0 +1,56 @@
+require 'digest'
+
+module RDBr
+  module Web
+    class ColumnPreferences
+      TRAILING_COLUMNS = %w[created_at updated_at discarded_at].freeze
+
+      attr_reader :cookie_name, :storage_key
+
+      def initialize(database:, namespace:, relation:, fixed_columns:, value: nil)
+        identity = [ database.adapter, database.name, namespace.name, relation.name ].join('/')
+        @columns = relation.columns.reject{|column| fixed_columns.include?(column.name) }
+        @preference = parse(value)
+        @cookie_name = "rdbr_columns_#{Digest::SHA256.hexdigest(identity).slice(0, 16)}"
+        @storage_key = "rdbr.columns.#{identity}"
+      end
+
+      def ordered_columns
+        preferred_names.filter_map{|name| columns_by_name[name] } +
+          default_columns.reject{|column| preferred_names.include?(column.name) }
+      end
+
+      def visible_columns
+        visible = ordered_columns.reject{|column| hidden_names.include?(column.name) }
+        visible.empty? ? ordered_columns.first(1) : visible
+      end
+
+      private
+
+      def parse(value)
+        parsed = JSON.parse(value.to_s)
+        parsed.is_a?(Hash) ? parsed : {}
+      rescue JSON::ParserError
+        {}
+      end
+
+      def preferred_names
+        @preferred_names ||= Array(@preference['order']).map(&:to_s).select{|name| columns_by_name.key?(name) }.uniq
+      end
+
+      def hidden_names
+        @hidden_names ||= Array(@preference['hidden']).map(&:to_s).select{|name| columns_by_name.key?(name) }
+      end
+
+      def columns_by_name
+        @columns_by_name ||= @columns.index_by(&:name)
+      end
+
+      def default_columns
+        ordinary = @columns.reject{|column| TRAILING_COLUMNS.include?(column.name) }
+        trailing = TRAILING_COLUMNS.filter_map{|name| columns_by_name[name] }
+        ordinary + trailing
+      end
+    end
+  end
+end

data/lib/rdbr/web/database_graph.rb

@@ -0,0 +1,91 @@
+module RDBr
+  module Web
+    class DatabaseGraph
+      class << self
+        def call(catalog)
+          @cache ||= {}.compare_by_identity
+          @cache[catalog] ||= JSON.generate(build(catalog))
+        end
+
+        private
+
+        def build(catalog)
+          relationships = graph_relationships(catalog)
+          {
+            database: catalog.name,
+            adapter: catalog.adapter,
+            nodes: graph_nodes(catalog, relationships),
+            edges: graph_edges(relationships)
+          }
+        end
+
+        def graph_relationships(catalog)
+          catalog.namespaces.flat_map do |namespace|
+            namespace.relations.flat_map do |relation|
+              catalog.outgoing_relationships(namespace, relation)
+            end
+          end
+        end
+
+        def graph_nodes(catalog, relationships)
+          catalog.namespaces.flat_map do |namespace|
+            namespace.relations.map do |relation|
+              outgoing = relationships.select do |relationship|
+                relationship.source_namespace == namespace && relationship.source_relation == relation
+              end
+              {
+                id: node_id(namespace.name, relation.name),
+                namespace: namespace.name,
+                name: relation.name,
+                kind: relation.kind,
+                comment: relation.comment,
+                columns: relation.columns.map{|column| graph_column(relation, column, outgoing) }
+              }
+            end
+          end
+        end
+
+        def graph_column(relation, column, relationships)
+          foreign_keys = relationships.filter_map do |relationship|
+            foreign_key = relationship.foreign_key
+            index = foreign_key.columns.index(column.name)
+            next unless index
+
+            {
+              namespace: relationship.target_namespace.name,
+              relation: relationship.target_relation.name,
+              column: foreign_key.referenced_columns.fetch(index),
+              inferred: relationship.inferred
+            }
+          end
+          {
+            name: column.name,
+            type: column.sql_type || column.logical_type,
+            nullable: column.nullable,
+            primary_key: relation.primary_key&.columns&.include?(column.name) || false,
+            foreign_keys: foreign_keys
+          }
+        end
+
+        def graph_edges(relationships)
+          relationships.map.with_index do |relationship, index|
+            foreign_key = relationship.foreign_key
+            {
+              id: "relationship:#{index}",
+              source: node_id(relationship.source_namespace.name, relationship.source_relation.name),
+              target: node_id(relationship.target_namespace.name, relationship.target_relation.name),
+              inferred: relationship.inferred,
+              columns: foreign_key.columns.zip(foreign_key.referenced_columns).map do |source, target|
+                { source: source, target: target }
+              end
+            }
+          end
+        end
+
+        def node_id(namespace, relation)
+          JSON.generate([ namespace, relation ])
+        end
+      end
+    end
+  end
+end

data/lib/rdbr/web/deferred_column_value_helpers.rb

@@ -0,0 +1,20 @@
+module RDBr
+  module Web
+    module DeferredColumnValueHelpers
+      private
+
+      def render_deferred_column_value(column, value)
+        return render_vector_value(column, value) if vector_column?(column)
+        return render_array_value(value) if deferred_array_value?(column, value)
+        return render_spatial_value(column, value) if spatial_column?(column)
+        return render_binary_value(value) if deferred_binary_value?(column, value)
+        return render_document_value(column, value) if deferred_document_value?(column)
+        return render_bit_value(value) if deferred_bit_value?(column)
+        return render_search_value(column, value) if deferred_search_value?(column)
+        return render_range_value(column, value) if range_column?(column)
+
+        render_unfamiliar_value(column, value) if deferred_unfamiliar_value?(column, value)
+      end
+    end
+  end
+end

data/lib/rdbr/web/deferred_value_helpers.rb

@@ -0,0 +1,76 @@
+module RDBr
+  module Web
+    module DeferredValueHelpers
+      COPY_ICON_PATH = [
+        'M8 7V5a2 2 0 0 1 2-2h9a2 2 0 0 1 2 2v12a2 2 0 0 1-2 2h-2v2H5a2 2 0 0 1-2-2V9',
+        'a2 2 0 0 1 2-2h3ZM10 7h5a2 2 0 0 1 2 2v8h2V5h-9v2Zm5 2H5v10h10V9Z'
+      ].join.freeze
+
+      def render_deferred_value(value, label: 'View', qualifier: nil, summary: nil)
+        escaped = Rack::Utils.escape_html(value.to_s)
+        classes = [ 'deferred-value-controls', qualifier && "#{qualifier}-controls" ].compact.join(' ')
+        [
+          %(<span class="#{classes}">),
+          deferred_view_button(escaped, label, qualifier),
+          deferred_value_summary(summary),
+          deferred_copy_button(escaped, qualifier),
+          '<span class="deferred-copy-status" aria-live="polite"></span></span>'
+        ].join
+      end
+
+      def render_deferred_dialog(dialog_id:, column_name:, text:, trigger:, content_class: nil)
+        id = Rack::Utils.escape_html(dialog_id)
+        label = Rack::Utils.escape_html("Show full #{column_name}")
+        content = Rack::Utils.escape_html(text)
+        class_attribute = content_class ? %( class="#{content_class}") : ''
+        dialog_attributes = %(id="#{id}" role="dialog" aria-modal="true" aria-label="#{label}" hidden)
+        [
+          trigger,
+          %(<div class="text-dialog popup-backdrop" #{dialog_attributes}><div class="text-dialog-panel popup-surface">),
+          '<button class="dialog-close" type="button" data-close-dialog aria-label="Close">×</button>',
+          deferred_dialog_copy_button(id),
+          "<pre#{class_attribute}>#{content}</pre></div></div>"
+        ].join
+      end
+
+      def safe_dom_name(name)
+        name.gsub(/[^a-zA-Z0-9_-]/, '-')
+      end
+
+      private
+
+      def deferred_view_button(value, label, qualifier)
+        classes = [ 'deferred-value-view', qualifier && "#{qualifier}-view" ].compact.join(' ')
+        attributes = %(data-view-value="#{value}" aria-haspopup="dialog" ) \
+                     'aria-controls="deferred-value-popover" aria-expanded="false"'
+        %(<button class="#{classes}" type="button" #{attributes}>#{Rack::Utils.escape_html(label)}</button>)
+      end
+
+      def deferred_value_summary(summary)
+        return '' if summary.to_s.empty?
+
+        %(<span class="deferred-value-summary">#{Rack::Utils.escape_html(summary)}</span>)
+      end
+
+      def deferred_copy_button(value, qualifier)
+        classes = [ 'deferred-value-copy', qualifier && "#{qualifier}-copy" ].compact.join(' ')
+        attributes = %(data-copy-value="#{value}" title="Copy to clipboard" aria-label="Copy value to clipboard")
+        %(<button class="#{classes}" type="button" #{attributes}>#{deferred_copy_icon}</button>)
+      end
+
+      def deferred_dialog_copy_button(dialog_id)
+        attributes = %(data-copy-target="#{dialog_id}" title="Copy to clipboard" ) \
+                     'aria-label="Copy displayed value to clipboard"'
+        [
+          %(<span class="deferred-dialog-copy"><button class="deferred-value-copy" type="button" ),
+          %(#{attributes}>#{deferred_copy_icon}</button>),
+          '<span class="deferred-copy-status" aria-live="polite"></span></span>'
+        ].join
+      end
+
+      def deferred_copy_icon
+        %(<svg aria-hidden="true" viewBox="0 0 24 24"><path d="#{COPY_ICON_PATH}"/></svg>)
+      end
+    end
+  end
+end

data/lib/rdbr/web/document_value_helpers.rb

@@ -0,0 +1,68 @@
+module RDBr
+  module Web
+    module DocumentValueHelpers
+      KEY_VALUE_TYPES = %i[hstore].freeze
+      DOCUMENT_TYPES = %i[xml].freeze
+
+      def deferred_document_value?(column)
+        type = column.logical_type.to_s.to_sym
+        KEY_VALUE_TYPES.include?(type) || DOCUMENT_TYPES.include?(type)
+      end
+
+      def render_document_value(column, value)
+        type = column.logical_type.to_s.to_sym
+        return render_hstore_value(value) if KEY_VALUE_TYPES.include?(type)
+
+        render_xml_value(value)
+      end
+
+      private
+
+      def render_hstore_value(value)
+        text, count = hstore_presentation(value)
+        return '<span class="empty">Empty</span>' if count.zero?
+
+        unit = count == 1 ? 'entry' : 'entries'
+        render_deferred_value(text, qualifier: 'structured', summary: "#{count} #{unit}")
+      end
+
+      def hstore_presentation(value)
+        return [ JSON.pretty_generate(value), value.length ] if value.is_a?(Hash)
+
+        entries = split_hstore(value.to_s)
+        [ entries.join(",\n"), entries.length ]
+      end
+
+      def split_hstore(text)
+        parts = []
+        start = 0
+        quoted = false
+        escaped = false
+        text.each_char.with_index do |character, index|
+          escaped, quoted = hstore_quote_state(character, escaped, quoted)
+          next unless character == ',' && !quoted
+
+          parts << text[start...index].strip
+          start = index + 1
+        end
+        parts << text[start..].to_s.strip
+        parts.reject(&:empty?)
+      end
+
+      def hstore_quote_state(character, escaped, quoted)
+        return [ false, quoted ] if escaped
+        return [ true, quoted ] if character == '\\'
+        return [ false, !quoted ] if character == '"'
+
+        [ false, quoted ]
+      end
+
+      def render_xml_value(value)
+        text = value.to_s
+        root = text.match(/<(?![!?])([[:alnum:]_.:-]+)/)&.[](1)
+        summary = root ? "XML document · <#{root}>" : 'XML document'
+        render_deferred_value(text, qualifier: 'structured', summary: summary)
+      end
+    end
+  end
+end