sqlui 0.1.18 → 0.1.20

data/app/sqlui.rb

@@ -1,230 +1,36 @@
 # frozen_string_literal: true
 
-require 'json'
-require 'uri'
-require 'set'
+require_relative 'sqlui_config'
+require_relative 'server'
 
-# Main SQLUI class responsible for producing web content. This class needs to die.
-class SQLUI
+# Main entry point.
+class Sqlui
   MAX_ROWS = 1_000
 
-  def initialize(client:, name:, saved_path:, table_schema: nil, max_rows: MAX_ROWS)
-    @client = client
-    @table_schema = table_schema
-    @name = name
-    @saved_path = saved_path
-    @max_rows = max_rows
-    @resources_dir = File.join(File.expand_path('..', File.dirname(__FILE__)), 'client', 'resources')
-  end
-
-  def get(params)
-    case params[:route]
-    when 'app'
-      { body: html, status: 200, content_type: 'text/html' }
-    when 'sqlui.css'
-      { body: css, status: 200, content_type: 'text/css' }
-    when 'sqlui.js'
-      { body: javascript, status: 200, content_type: 'text/javascript' }
-    when 'metadata'
-      { body: metadata.to_json, status: 200, content_type: 'application/json' }
-    when 'query_file'
-      { body: query_file(params).to_json, status: 200, content_type: 'application/json' }
-    else
-      { body: "unknown route: #{params[:route]}", status: 404, content_type: 'text/plain' }
-    end
-  end
-
-  def post(params)
-    case params[:route]
-    when 'query'
-      { body: query(params).to_json, status: 200, content_type: 'application/json' }
-    else
-      { body: "unknown route: #{params[:route]}", status: 404, content_type: 'text/plain' }
-    end
-  end
-
-  private
-
-  def html
-    @html ||= File.read(File.join(@resources_dir, 'sqlui.html'))
-  end
-
-  def css
-    @css ||= File.read(File.join(@resources_dir, 'sqlui.css'))
-  end
-
-  def javascript
-    @javascript ||= File.read(File.join(@resources_dir, 'sqlui.js'))
-  end
-
-  def query(params)
-    raise 'missing sql' unless params[:sql]
-    raise 'missing cursor' unless params[:cursor]
+  def initialize(config_file)
+    raise 'you must specify a configuration file' unless config_file
+    raise 'configuration file does not exist' unless File.exist?(config_file)
 
-    sql = find_query_at_cursor(params[:sql], Integer(params[:cursor]))
-    raise "can't find query at cursor" unless sql
-
-    execute_query(sql)
-  end
-
-  def query_file(params)
-    raise 'missing file param' unless params['file']
+    @config = SqluiConfig.new(config_file)
+    @resources_dir = File.join(File.expand_path('..', File.dirname(__FILE__)), 'client', 'resources')
 
-    sql = File.read("#{@saved_path}/#{params['file']}")
-    execute_query(sql).tap { |r| r[:file] = params[:file] }
+    # Connect to each database to verify each can be connected to.
+    @config.database_configs.each { |database| database.with_client { |client| client } }
   end
 
-  def metadata
-    load_metadata
+  def run
+    Server.init_and_run(@config, @resources_dir)
   end
 
-  def load_metadata
-    result = {
-      server: @name,
-      schemas: {},
-      saved: Dir.glob("#{@saved_path}/*.sql").map do |path|
-        {
-          filename: File.basename(path),
-          description: File.readlines(path).take_while { |l| l.start_with?('--') }.map { |l| l.sub(/^-- */, '') }.join
-        }
-      end
-    }
-
-    where_clause = if @table_schema
-                     "where table_schema = '#{@table_schema}'"
-                   else
-                     "where table_schema not in('mysql', 'sys', 'information_schema', 'performance_schema')"
-                   end
-    column_result = @client.query(
-      <<~SQL
-        select
-          table_schema,
-          table_name,
-          column_name,
-          data_type,
-          character_maximum_length,
-          is_nullable,
-          column_key,
-          column_default,
-          extra
-        from information_schema.columns
-        #{where_clause}
-        order by table_schema, table_name, column_name, ordinal_position;
-      SQL
-    )
-    column_result.each do |row|
-      row = row.transform_keys(&:downcase).transform_keys(&:to_sym)
-      table_schema = row[:table_schema]
-      unless result[:schemas][table_schema]
-        result[:schemas][table_schema] = {
-          tables: {}
-        }
-      end
-      table_name = row[:table_name]
-      tables = result[:schemas][table_schema][:tables]
-      unless tables[table_name]
-        tables[table_name] = {
-          indexes: {},
-          columns: {}
-        }
-      end
-      columns = result[:schemas][table_schema][:tables][table_name][:columns]
-      column_name = row[:column_name]
-      columns[column_name] = {} unless columns[column_name]
-      column = columns[column_name]
-      column[:name] = column_name
-      column[:data_type] = row[:data_type]
-      column[:length] = row[:character_maximum_length]
-      column[:allow_null] = row[:is_nullable]
-      column[:key] = row[:column_key]
-      column[:default] = row[:column_default]
-      column[:extra] = row[:extra]
+  def self.from_command_line(args)
+    if args.include?('-v') || args.include?('--version')
+      puts File.read('.version')
+      exit
     end
 
-    where_clause = if @table_schema
-                     "where table_schema = '#{@table_schema}'"
-                   else
-                     "where table_schema not in('mysql', 'sys', 'information_schema', 'performance_schema')"
-                   end
-    stats_result = @client.query(
-      <<~SQL
-        select
-          table_schema,
-          table_name,
-          index_name,
-          seq_in_index,
-          non_unique,
-          column_name
-        from information_schema.statistics
-        #{where_clause}
-        order by table_schema, table_name, if(index_name = "PRIMARY", 0, index_name), seq_in_index;
-      SQL
-    )
-    stats_result.each do |row|
-      row = row.transform_keys(&:downcase).transform_keys(&:to_sym)
-      table_schema = row[:table_schema]
-      tables = result[:schemas][table_schema][:tables]
-      table_name = row[:table_name]
-      indexes = tables[table_name][:indexes]
-      index_name = row[:index_name]
-      indexes[index_name] = {} unless indexes[index_name]
-      index = indexes[index_name]
-      column_name = row[:column_name]
-      index[column_name] = {}
-      column = index[column_name]
-      column[:name] = index_name
-      column[:seq_in_index] = row[:seq_in_index]
-      column[:non_unique] = row[:non_unique]
-      column[:column_name] = row[:column_name]
-    end
-
-    result
-  end
+    raise 'you must specify a configuration file' unless args.size == 1
+    raise 'configuration file does not exist' unless File.exist?(args[0])
 
-  def execute_query(sql)
-    result = @client.query(sql)
-    rows = result.map(&:values)
-    columns = result.first&.keys || []
-    column_types = columns.map { |_| 'string' }
-    unless rows.empty?
-      maybe_non_null_column_value_exemplars = columns.each_with_index.map do |_, index|
-        row = rows.find do |current|
-          !current[index].nil?
-        end
-        row.nil? ? nil : row[index]
-      end
-      column_types = maybe_non_null_column_value_exemplars.map do |value|
-        case value
-        when String, NilClass
-          'string'
-        when Integer
-          'number'
-        when Date, Time
-          'date'
-        else
-          value.class.to_s
-        end
-      end
-    end
-    {
-      query: sql,
-      columns: columns,
-      column_types: column_types,
-      total_rows: rows.size,
-      rows: rows.take(@max_rows)
-    }
-  end
-
-  def find_query_at_cursor(sql, cursor)
-    parts_with_ranges = []
-    sql.scan(/[^;]*;[ \n]*/) { |part| parts_with_ranges << [part, 0, part.size] }
-    parts_with_ranges.inject(0) do |pos, current|
-      current[1] += pos
-      current[2] += pos
-    end
-    part_with_range = parts_with_ranges.find do |current|
-      cursor >= current[1] && cursor < current[2]
-    end || parts_with_ranges[-1]
-    part_with_range[0]
+    Sqlui.new(args[0])
   end
 end

data/app/sqlui_config.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'database_config'
+require_relative 'args'
+
+# App config including database configs.
+class SqluiConfig
+  attr_reader :name, :list_url_path, :database_configs
+
+  def initialize(filename)
+    config = YAML.safe_load(ERB.new(File.read(filename)).result)
+    deep_symbolize!(config)
+    @name = Args.fetch_non_empty_string(config, :name).strip
+    @list_url_path = Args.fetch_non_empty_string(config, :list_url_path).strip
+    raise ArgumentError, 'list_url_path should start with a /' unless @list_url_path.start_with?('/')
+    if @list_url_path.length > 1 && @list_url_path.end_with?('/')
+      raise ArgumentError, 'list_url_path should not end with a /'
+    end
+
+    databases = Args.fetch_non_empty_hash(config, :databases)
+    @database_configs = databases.map do |_, current|
+      DatabaseConfig.new(current)
+    end
+  end
+
+  def database_config_for(url_path:)
+    config = @database_configs.find { |database| database.url_path == url_path }
+    raise ArgumentError, "no config found for path #{url_path}" unless config
+
+    config
+  end
+
+  private
+
+  def deep_symbolize!(object)
+    return object unless object.is_a? Hash
+
+    object.transform_keys!(&:to_sym)
+    object.each_value { |child| deep_symbolize!(child) }
+
+    object
+  end
+end

data/app/views/databases.erb

@@ -50,15 +50,15 @@
   </head>
 
   <body>
-    <h1>Databases</h1>
-    <% databases.values.each do |database| %>
-      <div class="database" onclick="window.location='<%= "/db/#{database['url_path']}/app" %>'">
-      <h2 class='name'><%= database['name'] %></h2>
-      <a class='query-link' href="/db/<%= database['url_path'] %>/app">query</a>
-      <a class='saved-link' href="/db/<%= database['url_path'] %>/app?tab=saved">saved</a>
-      <a class='structure-link' href="/db/<%= database['url_path'] %>/app?tab=structure">structure</a>
+    <h1><% config.name %> Databases</h1>
+    <% config.database_configs.each do |database_config| %>
+      <div class="database" onclick="window.location='<%= "#{database_config.url_path}/app" %>'">
+      <h2 class='name'><%= database_config.display_name %></h2>
+      <a class='query-link' href="<%= database_config.url_path %>/app">query</a>
+      <a class='saved-link' href="<%= database_config.url_path %>/app?tab=saved">saved</a>
+      <a class='structure-link' href="<%= database_config.url_path %>/app?tab=structure">structure</a>
       <p class='description'>
-        <%= database['description'] %>
+        <%= database_config.description %>
       </p>
     </div>
     <% end %>

data/bin/sqlui

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require_relative '../app/server'
+require_relative '../app/sqlui'
+
+Sqlui.from_command_line(ARGV).run