Add sqlite support for db commands (#183)

Author: timriley

Gemfile

@@ -17,7 +17,6 @@ gem "hanami-router", github: "hanami/router", branch: "main"
 gem "hanami-utils", github: "hanami/utils", branch: "main"
 
 gem "dry-files", github: "dry-rb/dry-files", branch: "main"
-gem "dry-system", github: "dry-rb/dry-system", branch: "main"
 
 gem "rack"
 

lib/hanami/cli/commands/app/db/command.rb

@@ -94,7 +94,7 @@ def build_database(slice)
             def warn_on_misconfigured_database(database, slices)
               if slices.length > 1
                 out.puts <<~STR
-                  WARNING: Database #{database.name} has config/db/ directories in multiple slices:
+                  WARNING: Database #{database.name} is configured for multiple config/db/ directories:
 
                   #{slices.map { "- " + _1.root.relative_path_from(_1.app.root).join("config", "db").to_s }.join("\n")}
 

lib/hanami/cli/commands/app/db/structure/load.rb

@@ -16,22 +16,32 @@ class Load < DB::Command
 
               # @api private
               def call(app: false, slice: nil, command_exit: method(:exit), **)
-                # TODO: handle exit_codes here
+                exit_codes = []
 
                 databases(app: app, slice: slice).each do |database|
                   structure_path = database.slice.root.join(STRUCTURE_PATH)
                   next unless structure_path.exist?
 
                   relative_structure_path = structure_path.relative_path_from(database.slice.app.root)
+
                   measure("#{database.name} structure loaded from #{relative_structure_path}") do
-                    database.exec_load_command.tap do |result|
+                    catch :load_failed do
+                      result = database.exec_load_command
+                      exit_codes << result.exit_code if result.respond_to?(:exit_code)
+
                       unless result.successful?
                         out.puts result.err
-                        break false
+                        throw :load_failed, false
                       end
+
+                      true
                     end
                   end
                 end
+
+                exit_codes.each do |code|
+                  break command_exit.(code) if code > 0
+                end
               end
             end
           end

lib/hanami/cli/commands/app/db/utils/database.rb

@@ -54,7 +54,6 @@ def initialize(slice:, system_call:)
               end
 
               def name
-                # Strip leading / - should this be skipped for sqlite?
                 database_uri.path.sub(%r{^/}, "")
               end
 
@@ -136,6 +135,10 @@ def migrations_dir?
                 migrations_path.directory?
               end
 
+              def structure_file
+                slice.root.join("config/db/structure.sql")
+              end
+
               def schema_migrations_sql_dump
                 sql = +"INSERT INTO schema_migrations (filename) VALUES\n"
                 sql << applied_migrations.map { |v| "('#{v}')" }.join(",\n")

lib/hanami/cli/commands/app/db/utils/postgres.rb

@@ -11,31 +11,42 @@ module App
         module DB
           module Utils
             # @api private
+            # @since 2.2.0
             class Postgres < Database
+              # @api private
+              # @since 2.2.0
               def exec_create_command
                 return true if exists?
 
                 system_call.call("createdb #{escaped_name}", env: cli_env_vars)
               end
 
+              # @api private
+              # @since 2.2.0
               def exec_drop_command
                 return true unless exists?
 
                 system_call.call("dropdb #{escaped_name}", env: cli_env_vars)
               end
 
+              # @api private
+              # @since 2.2.0
               def exists?
                 result = system_call.call("psql -t -A -c '\\list #{escaped_name}'", env: cli_env_vars)
                 result.successful? && result.out.include?("#{name}|") # start_with?
               end
 
+              # @api private
+              # @since 2.2.0
               def exec_dump_command
                 system_call.call(
                   "pg_dump --schema-only --no-privileges --no-owner --file #{structure_file} #{escaped_name}",
                   env: cli_env_vars
                 )
               end
 
+              # @api private
+              # @since 2.2.0
               def exec_load_command
                 system_call.call(
                   "psql --set ON_ERROR_STOP=1 --quiet --no-psqlrc --output #{File::NULL} --file #{structure_file} #{escaped_name}",
@@ -56,10 +67,6 @@ def cli_env_vars
                 end
               end
 
-              def structure_file
-                slice.root.join("config/db/structure.sql")
-              end
-
               def schema_migrations_sql_dump
                 search_path = slice["db.gateway"].connection
                   .fetch("SHOW search_path").to_a.first

lib/hanami/cli/commands/app/db/utils/sqlite.rb

@@ -9,41 +9,80 @@ module App
         module DB
           module Utils
             # @api private
+            # @since 2.2.0
             class Sqlite < Database
-              def name
-                @name ||= begin
-                  db_path = Pathname(database_uri.path).expand_path
-                  app_path = slice.app.root.realpath
+              # @api private
+              # @since 2.2.0
+              Failure = Struct.new(:err) do
+                def successful?
+                  false
+                end
 
-                  if db_path.to_s.start_with?("#{app_path.to_s}#{File::SEPARATOR}")
-                    db_path.relative_path_from(app_path).to_s
-                  else
-                    db_path.to_s
-                  end
+                def exit_code
+                  1
                 end
               end
 
-              def create_command
-                true
+              # @api private
+              # @since 2.2.0
+              def exec_create_command
+                return true if exists?
+
+                FileUtils.mkdir_p(File.dirname(file_path))
+
+                system_call.call(%(sqlite3 #{file_path} "VACUUM;"))
               end
 
-              def drop_command
-                file_path.unlink
+              # @api private
+              # @since 2.2.0
+              def exec_drop_command
+                begin
+                  File.unlink(file_path) if exists?
+                rescue => e
+                  # Mimic a system_call result
+                  return Failure.new(e.message)
+                end
+
                 true
               end
 
+              # @api private
+              # @since 2.2.0
+              def exists?
+                File.exist?(file_path)
+              end
+
+              # @api private
+              # @since 2.2.0
               def exec_dump_command
-                raise Hanami::CLI::NotImplementedError
+                system_call.call(%(sqlite3 #{file_path} ".schema --indent --nosys" > #{structure_file}))
               end
 
+              # @api private
+              # @since 2.2.0
               def exec_load_command
-                raise Hanami::CLI::NotImplementedError
+                system_call.call("sqlite3 #{file_path} < #{structure_file}")
+              end
+
+              # @api private
+              # @since 2.2.0
+              def name
+                # Sequel expects sqlite:// URIs to operate the same as file:// URIs: 2 slashes for
+                # a relative path, 3 for an absolute path. In the case of 2 slashes, the first part
+                # of the path is considered by Ruby's `URI` as the `#host`.
+                @name ||= "#{database_uri.host}#{database_uri.path}"
               end
 
               private
 
               def file_path
-                @file_path ||= Pathname(slice.root.join(config.uri.path)).realpath
+                @file_path ||= begin
+                  if File.absolute_path?(name)
+                    name
+                  else
+                    slice.app.root.join(name).to_s
+                  end
+                end
               end
             end
           end

spec/support/app_integration.rb

@@ -54,6 +54,9 @@ def autoloaders_teardown!
     Hanami.instance_variable_set(:@_bundled, {})
     Hanami.remove_instance_variable(:@_app) if Hanami.instance_variable_defined?(:@_app)
 
+    # Clear cached DB gateways across slices
+    Hanami::Providers::DB.cache.clear
+
     $LOAD_PATH.replace(@load_paths)
 
     # Remove example-specific LOADED_FEATURES added when running each example

spec/support/postgres.rb

@@ -4,7 +4,8 @@
 require "uri"
 
 # Default to a URL that should work with postgres as installed by asdf/mise.
-POSTGRES_BASE_URL = ENV.fetch("POSTGRES_BASE_URL", "postgres://postgres@localhost:5432/hanami_cli_test")
+POSTGRES_BASE_DB_NAME = "hanami_cli_test"
+POSTGRES_BASE_URL = ENV.fetch("POSTGRES_BASE_URL", "postgres://postgres@localhost:5432/#{POSTGRES_BASE_DB_NAME}")
 POSTGRES_BASE_URI = URI(POSTGRES_BASE_URL)
 
 RSpec.configure do |config|