sqlui 0.1.18 → 0.1.19

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f951e672b477e0fd4882c1aa4e42472975ac07fa6a2955eb4430bc1018ea6165
-  data.tar.gz: d8e7da6fe289ed3e94322a3ea3d5ce461356cbfa73e2e2732bab9001a8d3af24
+  metadata.gz: 3e42ae906ab341a224ba0904cf74be9224a13e6284e2ead198a382926e84db34
+  data.tar.gz: bd8f33a32f30179057914b9f291ff4af084f6917d8123f2bba550d5974df9b6f
 SHA512:
-  metadata.gz: 6769e3ee3c0b5330ca0b1ac1433370756838cec3187f0bd9822308704d31ee1608592199acb9b622edba8d45146c557e413d42c0a060bb9ace9b7653b43ad54c
-  data.tar.gz: 4ef70417125cdb931c5f6edba2ef7986be7bda22f0f27c362d7bea97df81752133493e9507b941cbfe51261fa4e77aca85f4838354805a97d88e64f0240e452d
+  metadata.gz: c1f4f3c0f0e180b6aea398da508f7bc551edd19fd77e24f60825bfb33c7f4130e1299770a160947d27854cc7dbd26d76fda6436528561b82720b0652815208dc
+  data.tar.gz: 1e275114bf9e63d2182c1a4a2a2390ebe97a14ad5b15d1b21ac0e276fbadce766203e42546cf09b6bbdaf9e0bc4c8abc451aa2756dc02334b2dc89f403ae6447

data/.version

@@ -1 +1 @@
-0.1.18
+0.1.19

data/app/database_config.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'mysql2'
+
+# Config for a single database.
+class DatabaseConfig
+  attr_reader :display_name, :description, :url_path, :saved_path, :client_params, :database
+
+  def initialize(hash)
+    @display_name = hash[:display_name].strip
+    @description = hash[:description].strip
+    @url_path = hash[:url_path].strip
+    raise ArgumentError, 'url_path should start with a /' unless @url_path.start_with?('/')
+    raise ArgumentError, 'url_path should not end with a /' if @url_path.length > 1 && @url_path.end_with?('/')
+
+    @saved_path = hash[:saved_path].strip
+    @client_params = hash[:client_params]
+    @database = @client_params[:database].strip
+  end
+
+  def with_client(&block)
+    client = Mysql2::Client.new(@client_params)
+    result = block.call(client)
+    client.close
+    client = nil
+    result
+  ensure
+    client&.close
+  end
+end

data/app/server.rb

@@ -2,11 +2,11 @@
 
 require 'erb'
 require 'json'
-require 'mysql2'
 require 'sinatra/base'
-require_relative 'sqlui'
-require 'yaml'
+require 'uri'
 require_relative 'environment'
+require_relative 'sql_parser'
+require_relative 'sqlui_config'
 
 if ARGV.include?('-v') || ARGV.include?('--version')
   puts File.read('.version')
@@ -18,78 +18,249 @@ raise 'configuration file does not exist' unless File.exist?(ARGV[0])
 
 # SQLUI Sinatra server.
 class Server < Sinatra::Base
+  MAX_ROWS = 1_000
+
+  CONFIG = SqluiConfig.new(ARGV[0])
+
+  def initialize(app = nil, **_kwargs)
+    super
+    @config = Server::CONFIG
+    @resources_dir = File.join(File.expand_path('..', File.dirname(__FILE__)), 'client', 'resources')
+  end
+
   set :logging, true
   set :bind,    '0.0.0.0'
   set :port,    Environment.server_port
   set :env,     Environment.server_env
 
-  # A MySQL client. This needs to go away.
-  class Client
-    def initialize(params)
-      @params = params
+  get '/-/health' do
+    status 200
+    body 'OK'
+  end
+
+  get "#{CONFIG.list_url_path}/?" do
+    erb :databases, locals: { config: @config }
+  end
+
+  CONFIG.database_configs.each do |database|
+    get database.url_path.to_s do
+      redirect "#{params[:database]}/app", 301
     end
 
-    def query(sql)
-      client = Thread.current.thread_variable_get(:client)
-      unless client
-        client = Mysql2::Client.new(@params)
-        Thread.current.thread_variable_set(:client, client)
+    get "#{database.url_path}/app" do
+      @html ||= File.read(File.join(@resources_dir, 'sqlui.html'))
+      status 200
+      headers 'Content-Type': 'text/html'
+      body @html
+    end
+
+    get "#{database.url_path}/sqlui.css" do
+      @css ||= File.read(File.join(@resources_dir, 'sqlui.css'))
+      status 200
+      headers 'Content-Type': 'text/css'
+      body @css
+    end
+
+    get "#{database.url_path}/sqlui.js" do
+      @js ||= File.read(File.join(@resources_dir, 'sqlui.js'))
+      status 200
+      headers 'Content-Type': 'text/javascript'
+      body @js
+    end
+
+    get "#{database.url_path}/metadata" do
+      database_config = @config.database_config_for(url_path: database.url_path)
+      metadata = database_config.with_client do |client|
+        load_metadata(client, database_config.database, database_config.saved_path)
       end
-      client.query(sql)
+      status 200
+      headers 'Content-Type': 'application/json'
+      body metadata.to_json
     end
-  end
 
-  config = YAML.safe_load(ERB.new(File.read(ARGV[0])).result)
-  saved_path_root = config['saved_path']
-  client_map = config['databases'].values.to_h do |database_config|
-    client_params = {
-      host: database_config['db_host'],
-      port: database_config['db_port'] || 3306,
-      username: database_config['db_username'],
-      password: database_config['db_password'],
-      database: database_config['db_database'],
-      read_timeout: 10, # seconds
-      write_timeout: 0, # seconds
-      connect_timeout: 5   # seconds
-    }
-    client = Client.new(client_params)
-    [
-      database_config['url_path'],
-      ::SQLUI.new(
-        client: client,
-        table_schema: database_config['db_database'],
-        name: database_config['name'],
-        saved_path: File.join(saved_path_root, database_config['saved_path'])
-      )
-    ]
-  end
+    get "#{database.url_path}/query_file" do
+      return client_error('missing file param') unless params[:file]
+      return client_error('no such file') unless File.exist?(params[:file])
 
-  get '/-/health' do
-    status 200
-    body 'OK'
-  end
+      database_config = @config.database_config_for(url_path: database.url_path)
+      sql = File.read(File.join(database_config.saved_path, params[:file]))
+      result = database_config.with_client do |client|
+        execute_query(client, sql).tap { |r| r[:file] = params[:file] }
+      end
+
+      status 200
+      headers 'Content-Type': 'application/json'
+      body result.to_json
+    end
+
+    post "#{database.url_path}/query" do
+      params.merge!(JSON.parse(request.body.read, symbolize_names: true))
+      return client_error('missing sql') unless params[:sql]
+      return client_error('missing cursor') unless params[:cursor]
+
+      sql = SqlParser.find_statement_at_cursor(params[:sql], Integer(params[:cursor]))
+      raise "can't find query at cursor" unless sql
 
-  get '/db/?' do
-    erb :databases, locals: { databases: config['databases'] }
+      database_config = @config.database_config_for(url_path: database.url_path)
+      result = database_config.with_client do |client|
+        execute_query(client, sql)
+      end
+
+      status 200
+      headers 'Content-Type': 'application/json'
+      body result.to_json
+    end
   end
 
-  get '/db/:database' do
-    redirect "/db/#{params[:database]}/app", 301
+  private
+
+  def client_error(message, stacktrace: nil)
+    status(400)
+    headers('Content-Type': 'application/json')
+    body({ message: message, stacktrace: stacktrace }.compact.to_json)
   end
 
-  get '/db/:database/:route' do
-    response = client_map[params[:database]].get(params)
-    status response[:status]
-    headers 'Content-Type': response[:content_type]
-    body response[:body]
+  def load_metadata(client, database, saved_path)
+    result = {
+      server: @config.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 database
+                     "where table_schema = '#{database}'"
+                   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]
+    end
+
+    where_clause = if database
+                     "where table_schema = '#{database}'"
+                   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
 
-  post '/db/:database/:route' do
-    post_body = JSON.parse(request.body.read)
-    response = client_map[params[:database]].post(params.merge(post_body))
-    status response[:status]
-    headers 'Content-Type': response[:content_type]
-    body response[:body]
+  def execute_query(client, sql)
+    result = client.query(sql, cast: false)
+    rows = result.map(&:values)
+    columns = result.first&.keys || []
+    # TODO: use field_types
+    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, Float
+          'number'
+        when Date
+          'date'
+        when Time
+          'datetime'
+        when TrueClass, FalseClass
+          'boolean'
+        else
+          # TODO: report an error
+          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
 
   run!

data/app/sql_parser.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+# Used to parse strings containing one or more SQL statements.
+class SqlParser
+  def self.find_statement_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].strip
+  end
+end

data/app/sqlui_config.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+require 'yaml'
+require_relative 'database_config'
+
+# 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 = fetch_non_empty_string(config, :name).strip
+    @list_url_path = 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 = config[:databases]
+    if databases.nil? || !databases.is_a?(Hash) || databases.empty?
+      raise ArgumentError, 'required parameter databases missing'
+    end
+
+    @database_configs = databases.map do |_, current|
+      DatabaseConfig.new(current)
+    end
+  end
+
+  def database_config_for(url_path:)
+    @database_configs.find { |database| database.url_path == url_path } || raise("no config found for path #{url_path}")
+  end
+
+  private
+
+  def fetch_non_empty_string(hash, key)
+    value = hash[key]
+    raise ArgumentError, "required parameter #{key} missing" if value.nil? || !value.is_a?(String) || value.strip.empty?
+
+    value.strip
+  end
+
+  def deep_symbolize!(object)
+    return unless object.is_a? Hash
+
+    object.transform_keys!(&:to_sym)
+    object.each_value { |child| deep_symbolize!(child) }
+  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 %>

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sqlui
 version: !ruby/object:Gem::Version
-  version: 0.1.18
+  version: 0.1.19
 platform: ruby
 authors:
 - Nick Dower
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-10-24 00:00:00.000000000 Z
+date: 2022-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mysql2
@@ -158,9 +158,11 @@ extensions: []
 extra_rdoc_files: []
 files:
 - ".version"
+- app/database_config.rb
 - app/environment.rb
 - app/server.rb
-- app/sqlui.rb
+- app/sql_parser.rb
+- app/sqlui_config.rb
 - app/views/databases.erb
 - bin/sqlui
 - client/resources/sqlui.css

data/app/sqlui.rb

@@ -1,230 +0,0 @@
-# frozen_string_literal: true
-
-require 'json'
-require 'uri'
-require 'set'
-
-# Main SQLUI class responsible for producing web content. This class needs to die.
-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]
-
-    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']
-
-    sql = File.read("#{@saved_path}/#{params['file']}")
-    execute_query(sql).tap { |r| r[:file] = params[:file] }
-  end
-
-  def metadata
-    load_metadata
-  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]
-    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
-
-  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]
-  end
-end