pg_export 1.0.0.rc5 → 1.0.0.rc6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b927b4b2f8c0ca36682a15ae9f90aa975980d9d3874989f7ab19fe256fcecb7d
-  data.tar.gz: b653c480d52143bf58864f7904a404a21802aa389e9b24ee9f271dbafa064969
+  metadata.gz: ca033b9c62cc381584bd9696e9607b63d89f52310a5847b714908c7140e755dc
+  data.tar.gz: 755e0fa8760fa1ba6b2d3d8af65532da26b9a8978b5005853d9aaede8131d748
 SHA512:
-  metadata.gz: c1ae01b513f51ef4675b1dbae7337ac6ffe11d3ca481bf272ea6338e1f1b1bcd5fb75b240aefdcc12117e721a6097e945b1832af56344ac232ebfad55a5e98db
-  data.tar.gz: 31dc4ab7b943ce973f14b6a42867d388fa18a8c8f56d52bd9c0e5e30b241258555e804a4d59b53ed9d409fae8d7a8aa8ad8a130356383b66cbbbc4b1a1b75aba
+  metadata.gz: 01a50e23dff7a059c606aaff6ea744f3ee3da607ffcf5062514c447a0f9413386a7df378ae7467ff9e35745b65d5a78fa96c6e9abf93b6cff2d8dc4fa9be5e55
+  data.tar.gz: a32e7517a57dcc5eee39c40334ea5552709930d2e5bd402eaf55e67c96625b528aa40f99ef2ee5cdbacae8ad052250d2122f87eb83705ab85fa41599a755fff0

data/.rubocop.yml

@@ -6,17 +6,32 @@ Metrics/BlockLength:
     - 'bin/pg_export'
   ExcludedMethods: ['describe', 'context']
 
-Metrics/LineLength:
-  Max: 200
+Layout/LineLength:
+  Max: 140
 
 Style/ParallelAssignment:
   Enabled: false
 
-Naming/UncommunicativeMethodParamName:
+Naming/MethodParameterName:
   Enabled: false
 
-Documentation:
+Style/Documentation:
   Enabled: false
 
 Lint/UnusedMethodArgument:
   Enabled: false
+
+Metrics/MethodLength:
+  Max: 50
+
+Metrics/CyclomaticComplexity:
+  Max: 30
+
+Style/TrailingCommaInHashLiteral:
+  Enabled: false
+
+Metrics/AbcSize:
+  Max: 30
+
+Metrics/PerceivedComplexity:
+  Max: 30

data/CHANGELOG.md

@@ -1,4 +1,4 @@
-### 1.0.0 - 2021.03.20
+### 1.0.0 - 2022.05.17
 - Make it compatible with Ruby 3.0
 - Change configuration envs:
   - BACKUP_FTP_HOST -> PG_EXPORT_GATEWAY_HOST
@@ -7,15 +7,17 @@
   - DUMP_ENCRYPTION_KEY -> PG_EXPORT_ENCRYPTION_KEY
 - Drop Ruby 2.3 support
 - Add SSH option
-- Add +encryption_algorith+ moption to interface
+- Add `encryption_algorithm` option to interface
+- Remove dry libraries dependencies
+- in case of failure bin/pg_export now returns with 1 exit value
 
 ### 0.7.7 - 2020.09.07
 
-- Upgrade dry-initializer 
+- Upgrade dry-initializer
 
 ### 0.7.6 - 2020.09.05
 
-- Upgrade dry-types, dry-struct dry-system 
+- Upgrade dry-types, dry-struct dry-system
 
 ### 0.7.0 - 2018.10.18
 
@@ -41,7 +43,7 @@
 
 ### 0.5.0 - 2017.03.11
 
-- Add restriction on DUMP_ENCRYPTION_KEY, to be exactly 16 characters length 
+- Add restriction on DUMP_ENCRYPTION_KEY, to be exactly 16 characters length
 - Make interactive mode more verbose by adding more messages
 - Fix concurrently opening ftp connection
 - Add closing ftp connection while importing dump in interactive mode

data/README.md

@@ -11,7 +11,7 @@ Can be used for backups or synchronizing databases between production and develo
 Example:
 
     pg_export --database database_name --keep 5
-    
+
 Above command will perform database dump, encrypt it, upload it to FTP and remove old dumps from FTP, keeping newest 5.
 
 FTP connection params and encryption key are configured by env variables.
@@ -50,20 +50,38 @@ Or install it yourself as:
 
     $ pg_export -h
 
-    Usage: pg_export [options]
-        -g, --gateway GATEWAY            [Optional] ssh or ftp (default: ftp)
-        -d, --database DATABASE          [Required] Name of the database to export
-        -k, --keep [KEEP]                [Optional] Number of dump files to keep on FTP (default: 10)
-        -t, --timestamped                [Optional] Enables log messages with timestamps
-        -m, --muted                      [Optional] Mutes log messages (overrides -t option)
-        -i, --interactive                [Optional] Interactive command line mode - for restoring dumps into databases
-        -v, --version                    Show version
-        -h, --help                       Show this message
-
-    Setting can be verified by running following commands:
-        -c, --configuration              Prints the configuration
-        -w, --welcome                    Tries connecting to the gateway (FTP or SSH) to verify the connection
-
+    SYNOPSIS
+      pg_export DATABASE [OPTION..]
+      pg_export --interactive DATABASE [OPTION..]
+
+    ARGUMENTS
+      DATABASE - database name to export (when default mode)
+           - phrase to filter database dumps by (when interactive mode)
+
+    OPTIONS
+      -g, --gateway GATEWAY            Allowed values: ftp, ssh. Default: ftp. Credentials need to be set via ENVs
+      -s, --ssh                        Same as "--gateway ssh"
+      -f, --ftp                        Same as "--gateway ftp"
+      -d, --database DATABASE          Alternative way of specifying name of the database to export or phrase to filter by
+      -e, --encryption_key KEY         Dumps will be SSL encrypted using this key. Should have exactly 16 characters. Overwrites PG_EXPORT_ENCRYPTION_KEY env
+      -a, --algorithm ALGORITHM        Encryption cipher algorithm (default: AES-128-CBC). Overwrites PG_EXPORT_ENCRYPTION_ALGORITHM env. For available option see `$ openssl list -cipher-algorithms`
+      -k, --keep KEEP                  Number of dump files to keep on FTP (default: 10). Overwrites KEEP_DUMPS env
+      -t, --timestamped                Enables log messages with timestamps
+      -m, --muted                      Mutes log messages (overrides -t option)
+      -i, --interactive                Interactive mode, for importing dumps
+      -v, --version                    Show version
+      -h, --help                       Show this message
+
+    ENV
+      PG_EXPORT_GATEWAY_HOST           required
+      PG_EXPORT_GATEWAY_USER           required
+      PG_EXPORT_GATEWAY_PASSWORD       optional when eg. authorized key is added
+      PG_EXPORT_ENCRYPTION_KEY         required or set by --encryption_key)
+      PG_EXPORT_ENCRYPTION_ALGORITHM   required or set by --algorithm)
+
+    TEST RUN
+      -c, --configuration              Print the configuration
+      -w, --welcome                    Try connecting to the gateway (FTP or SSH) to verify the connection
 
 ## How to start
 
@@ -73,28 +91,32 @@ __Step 1.__ Prepare ENV variables.
     PG_EXPORT_GATEWAY_HOST=yourftp.example.com
     PG_EXPORT_GATEWAY_USER=user
     PG_EXPORT_GATEWAY_PASSWORD=password
-    
+
     /* Encryption key should have exactly 16 characters. */
     /* Dumps will be SSL(AES-128-CBC) encrypted using this key. */
     PG_EXPORT_ENCRYPTION_KEY=1234567890abcdef
-    
+
     /* Dumps to be kept on FTP */
     /* Optional, defaults to 10 */
     KEEP_DUMPS=5
-    
-Note, that variables cannot include `#` sign, [more info](http://serverfault.com/questions/539730/environment-variable-in-etc-environment-with-pound-hash-sign-in-the-value). 
+
+Note, that variables cannot include `#` sign, [more info](http://serverfault.com/questions/539730/environment-variable-in-etc-environment-with-pound-hash-sign-in-the-value).
 
 __Step 2.__ Print the configuration to verify if env variables has been loaded properly.
 
     $ pg_export --configuration
-    => {:encryption_key=>"k4***", :gateway_host=>"yourftp.example.com", :gateway_user=>"your_gateway_user",
-       :gateway_password=>"pass***", :logger_format=>"plain", :keep_dumps=>2}
-       
+    => encryption_key k4***
+       gateway_host yourftp.example.com
+       gateway_user your_gateway_user
+       gateway_password pass***
+       logger_format plain
+       keep_dumps 2
+
 __Step 3.__ Try connecting to FTP to verify the connection.
 
     $ pg_export --gateway ftp --welcome
     => 230 User your_ftp_user logged in
-    
+
 __Step 4.__ Perform database export.
 
     $ pg_export -d your_database [-k 5]
@@ -103,7 +125,7 @@ __Step 4.__ Perform database export.
        Connect to yourftp.example.com
        Upload your_database_20181016_121314 (1.34MB) to yourftp.example.com
        Close FTP
-       
+
 ## How to restore a dump?
 
 Run interactive mode and follow the instructions:

data/bin/pg_export

@@ -1,28 +1,27 @@
 #!/usr/bin/env ruby
 # frozen_string_literal: true
 
-require 'optparse'
+lib = File.expand_path('../lib', __dir__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 
+require 'optparse'
 require 'pg_export'
-require 'pg_export/version'
-
-ENV['KEEP_DUMPS'] = ENV['KEEP_DUMPS'] || '10'
-ENV['GATEWAY'] = 'ftp'
-ENV['PG_EXPORT_MODE'] = 'plain'
-ENV['PG_EXPORT_ENCRYPTION_ALGORITHM'] = 'AES-128-CBC'
 
 database = nil
+x = nil
 
 option_parser = OptionParser.new do |opts|
   opts.banner = <<~TXT
     NAME
         pg_export - CLI for exporting/importing PostgreSQL dumps via FTP/SSH
 
-    SYNOPSIS (default mode)
-        pg_export DATABASE [options]
+    SYNOPSIS
+        pg_export DATABASE [OPTION..]
+        pg_export --interactive DATABASE [OPTION..]
 
-    SYNOPSIS (interactive mode)
-        pg_export --interactive [DATABASE] [options]
+    EXIT VALUES
+        0 - Success
+        1 - Error
 
     ARGUMENTS
         DATABASE - database name to export (when default mode)
@@ -97,18 +96,11 @@ option_parser = OptionParser.new do |opts|
   opts.separator "\nTEST RUN"
 
   opts.on('-c', '--configuration', 'Print the configuration') do
-    require 'pg_export/container'
-    PgExport::Container.start(:config)
-    puts PgExport::Container['config'].to_h
-    exit
+    x = -> { puts PgExport.new.config }
   end
 
   opts.on('-w', '--welcome', 'Try connecting to the gateway (FTP or SSH) to verify the connection') do
-    require 'pg_export/container'
-    PgExport::Container.start(ENV['GATEWAY'].to_sym)
-    gateway = PgExport::Container['factories.gateway_factory'].gateway
-    puts gateway.welcome
-    exit
+    x = -> { puts PgExport.new.gateway_welcome }
   end
 
   if ARGV.empty?
@@ -119,30 +111,36 @@ end
 
 begin
   option_parser.parse!
+  if x
+    x.call
+    exit
+  end
   database = ARGV.first unless ARGV.empty?
 rescue OptionParser::ParseError => e
   warn e.message.capitalize
   warn 'Details:'
   warn option_parser.to_s.split("\n").grep(/ #{e.args.first}/).join("\n")
   warn 'Type "pg_export" for available options'
-  exit
+  exit 1
 end
 
-require 'pg_export/container'
-
 begin
-  pg_export = PgExport.boot
+  pg_export = PgExport.new
 rescue PgExport::InitializationError => e
   warn 'Unable to initialize PgExport due to invalid configuration. Check you ENVs.'
   warn "Detailed message: #{e.message}"
-  exit
+  exit 1
 end
 
 begin
-  pg_export.call(database) do |result|
-    result.success { puts 'Success' }
-    result.failure { |outcome| warn outcome[:message] }
-  end
+  pg_export
+    .call(database)
+    .on_success { exit 0 }
+    .on_failure do |outcome|
+      warn outcome[:message]
+      exit 1
+    end
+
 rescue Interrupt
   puts
 end

data/lib/pg_export/configuration.rb

@@ -1,19 +1,19 @@
 # frozen_string_literal: true
 
-require 'pg_export/lib/pg_export/types'
-require 'dry-struct'
-
 class PgExport
-  class Configuration < Dry::Struct
-    attribute :encryption_key,       PgExport::Types::Strict::String.constrained(size: 16)
-    attribute :encryption_algorithm, PgExport::Types::Strict::String
-    attribute :gateway_host,         PgExport::Types::Strict::String
-    attribute :gateway_user,         PgExport::Types::Strict::String
-    attribute :gateway_password,     PgExport::Types::Strict::String.optional
-    attribute :logger_format,        PgExport::Types::Coercible::Symbol.enum(:plain, :timestamped, :muted)
-    attribute :keep_dumps,           PgExport::Types::Coercible::Integer.constrained(gteq: 0)
-    attribute :gateway,              PgExport::Types::Coercible::Symbol.enum(:ftp, :ssh)
-    attribute :mode,                 PgExport::Types::Coercible::Symbol.enum(:plain, :interactive)
+  class Configuration
+    ATTRS = %i[
+      encryption_key
+      encryption_algorithm
+      gateway_host
+      gateway_user
+      gateway_password
+      logger_format
+      keep_dumps
+      gateway mode
+    ].freeze
+
+    attr_reader *ATTRS
 
     def self.build(env)
       new(
@@ -21,14 +21,66 @@ class PgExport
         encryption_algorithm: env['PG_EXPORT_ENCRYPTION_ALGORITHM'],
         gateway_host: env['PG_EXPORT_GATEWAY_HOST'],
         gateway_user: env['PG_EXPORT_GATEWAY_USER'],
-        gateway_password: env['PG_EXPORT_GATEWAY_PASSWORD'] == '' ? nil : env['PG_EXPORT_GATEWAY_PASSWORD'],
-        logger_format: env['LOGGER_FORMAT'] || 'plain',
-        keep_dumps: env['KEEP_DUMPS'] || 10,
+        gateway_password: env['PG_EXPORT_GATEWAY_PASSWORD'],
+        logger_format: env['LOGGER_FORMAT'],
+        keep_dumps: env['KEEP_DUMPS'],
         gateway: env['GATEWAY'],
         mode: env['PG_EXPORT_MODE']
       )
-    rescue Dry::Struct::Error => e
-      raise PgExport::InitializationError, e.message.gsub('[PgExport::Configuration.new] ', '')
+    end
+
+    def initialize(
+      encryption_key: nil,
+      encryption_algorithm: nil,
+      gateway_host: nil,
+      gateway_user: nil,
+      gateway_password: nil,
+      logger_format: nil,
+      keep_dumps: nil,
+      gateway: nil,
+      mode: nil
+    )
+
+      @encryption_key = String(encryption_key)
+      raise ArgumentError, 'Encryption key must be 16 chars long' if @encryption_key.length != 16
+
+      @encryption_algorithm = String(encryption_algorithm)
+      @encryption_algorithm = 'AES-128-CBC' if @encryption_algorithm.empty?
+
+      @gateway_host = String(gateway_host)
+      raise ArgumentError, 'Gatway host must not be empty' if @gateway_host.empty?
+
+      @gateway_user = String(gateway_user)
+      raise ArgumentError, 'Gatway user must not be empty' if @gateway_user.empty?
+
+      @gateway_password = nil if gateway_password.nil? || gateway_password.to_s.empty?
+
+      @logger_format = logger_format.to_s.to_sym
+      @logger_format = :plain if @logger_format.empty?
+      raise ArgumentError, 'Logger format must be one of: plain, timestamped, muted' unless %i[plain timestamped muted].include?(@logger_format)
+
+      @keep_dumps = Integer(keep_dumps || 10)
+      raise ArgumentError, 'Keep dumps must greater or equal to 1' unless @keep_dumps >= 1
+
+      @gateway = gateway.to_s.to_sym
+      @gateway = :ftp if @gateway.empty?
+      raise ArgumentError, 'Gateway must be one of: ftp, ssh' unless %i[ftp ssh].include?(@gateway)
+
+      @mode = mode.to_s.to_sym
+      @mode = :plain if @mode.empty?
+      raise ArgumentError, 'Mode must be one of: plain, interactive' unless %i[plain interactive].include?(@mode)
+    end
+
+    def to_s
+      ATTRS.map do |name|
+        value = public_send(name)
+
+        if %i[encryption_key gateway_password].include?(name)
+          "  #{name} #{value.nil? ? '' : value[0..2] + '***'}"
+        else
+          "  #{name} #{value}"
+        end
+      end.join("\n")
     end
   end
 end

data/lib/pg_export/factory.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+class PgExport
+  class Factory
+    attr_reader :config
+
+    def initialize(config:)
+      @config = config
+    end
+
+    def gateway_factory
+      if config.gateway == :ftp
+        require 'pg_export/lib/pg_export/factories/ftp_gateway_factory'
+
+        Factories::FtpGatewayFactory.new(config: config)
+      elsif config.gateway == :ssh
+        require 'pg_export/lib/pg_export/factories/ssh_gateway_factory'
+
+        Factories::SshGatewayFactory.new(config: config)
+      else
+        raise ArgumentError, "Unknown gateway #{config.gateway}"
+      end
+    end
+
+    def transaction
+      require 'pg_export/lib/pg_export/operations/encrypt_dump'
+      require 'pg_export/lib/pg_export/operations/decrypt_dump'
+      require 'pg_export/lib/pg_export/operations/open_connection'
+      require 'pg_export/lib/pg_export/factories/cipher_factory'
+      require 'pg_export/lib/pg_export/factories/dump_factory'
+      require 'pg_export/lib/pg_export/adapters/shell_adapter'
+      require 'pg_export/lib/pg_export/repositories/gateway_dump_repository'
+      require 'pg_export/lib/pg_export/repositories/gateway_dump_file_repository'
+
+      cipher_factory = Factories::CipherFactory.new(
+        encryption_algorithm: config.encryption_algorithm,
+        encryption_key: config.encryption_key
+      )
+
+      gateway_dump_repository = Repositories::GatewayDumpRepository.new
+      gateway_dump_file_repository = Repositories::GatewayDumpFileRepository.new
+      open_connection = Operations::OpenConnection.new(gateway_factory: gateway_factory)
+      bash_adapter = Adapters::ShellAdapter.new
+
+      encrypt_dump = Operations::EncryptDump.new(cipher_factory: cipher_factory)
+
+      if config.mode == :plain
+        require 'pg_export/lib/pg_export/operations/remove_old_dumps'
+        require 'pg_export/lib/pg_export/transactions/export_dump'
+
+        remove_old_dumps = Operations::RemoveOldDumps.new(
+          gateway_dump_repository: gateway_dump_repository,
+          keep: config.keep_dumps
+        )
+
+        PgExport::Transactions::ExportDump.new(
+          dump_factory: Factories::DumpFactory.new,
+          bash_adapter: bash_adapter,
+          encrypt_dump: encrypt_dump,
+          open_connection: open_connection,
+          remove_old_dumps: remove_old_dumps,
+          listeners: plain_listeners
+        )
+      elsif config.mode == :interactive
+        require 'pg_export/lib/pg_export/transactions/import_dump_interactively'
+        require 'pg_export/lib/pg_export/ui/interactive/input'
+
+        decrypt_dump = Operations::DecryptDump.new(cipher_factory: cipher_factory)
+
+        PgExport::Transactions::ImportDumpInteractively.new(
+          input: Ui::Interactive::Input.new,
+          bash_adapter: bash_adapter,
+          gateway_dump_file_repository: gateway_dump_file_repository,
+          gateway_dump_repository: gateway_dump_repository,
+          open_connection: open_connection,
+          decrypt_dump: decrypt_dump,
+          listeners: interactive_listeners
+        )
+      else
+        raise ArgumentError, "Unknown mode #{config.mode}"
+      end
+    end
+
+    private
+
+    def plain_listeners
+      require 'pg_export/lib/pg_export/listeners/plain/prepare_params'
+      require 'pg_export/lib/pg_export/listeners/plain/build_dump'
+      require 'pg_export/lib/pg_export/listeners/plain/close_connection'
+      require 'pg_export/lib/pg_export/listeners/plain/decrypt_dump'
+      require 'pg_export/lib/pg_export/listeners/plain/download_dump'
+      require 'pg_export/lib/pg_export/listeners/plain/encrypt_dump'
+      require 'pg_export/lib/pg_export/listeners/plain/fetch_dumps'
+      require 'pg_export/lib/pg_export/listeners/plain/open_connection'
+      require 'pg_export/lib/pg_export/listeners/plain/remove_old_dumps'
+      require 'pg_export/lib/pg_export/listeners/plain/restore'
+      require 'pg_export/lib/pg_export/listeners/plain/upload_dump'
+
+      logger = build_logger(config.logger_format)
+
+      {
+        prepare_params: Listeners::Plain::PrepareParams.new(logger: logger),
+        build_dump: Listeners::Plain::BuildDump.new(logger: logger),
+        encrypt_dump: Listeners::Plain::EncryptDump.new(logger: logger),
+        open_connection: Listeners::Plain::OpenConnection.new(logger: logger),
+        upload_dump: Listeners::Plain::UploadDump.new(logger: logger),
+        remove_old_dumps: Listeners::Plain::RemoveOldDumps.new(logger: logger),
+        close_connection: Listeners::Plain::CloseConnection.new(logger: logger)
+      }
+    end
+
+    def interactive_listeners
+      require 'pg_export/lib/pg_export/listeners/interactive/open_connection'
+      require 'pg_export/lib/pg_export/listeners/interactive/fetch_dumps'
+      require 'pg_export/lib/pg_export/listeners/interactive/select_dump'
+      require 'pg_export/lib/pg_export/listeners/interactive/download_dump'
+      require 'pg_export/lib/pg_export/listeners/interactive/close_connection'
+      require 'pg_export/lib/pg_export/listeners/interactive/decrypt_dump'
+      require 'pg_export/lib/pg_export/listeners/interactive/select_database'
+      require 'pg_export/lib/pg_export/listeners/interactive/restore'
+
+      {
+        open_connection: Listeners::Interactive::OpenConnection.new,
+        fetch_dumps: Listeners::Interactive::FetchDumps.new,
+        select_dump: Listeners::Interactive::SelectDump.new,
+        download_dump: Listeners::Interactive::DownloadDump.new,
+        close_connection: Listeners::Interactive::CloseConnection.new,
+        decrypt_dump: Listeners::Interactive::DecryptDump.new,
+        select_database: Listeners::Interactive::SelectDatabase.new,
+        restore: Listeners::Interactive::Restore.new,
+      }
+    end
+
+    def build_logger(logger_format)
+      require 'logger'
+
+      formatters = {
+        plain: ->(_, _, _, message) { "#{message}\n" },
+        muted: ->(*) {},
+        timestamped: lambda do |severity, datetime, progname, message|
+          "#{datetime} #{Process.pid} TID-#{Thread.current.object_id.to_s(36)}#{progname} #{severity}: #{message}\n"
+        end
+      }
+
+      Logger.new($stdout, formatter: formatters.fetch(logger_format))
+    end
+  end
+end

data/lib/pg_export/lib/pg_export/adapters/{bash_adapter.rb → shell_adapter.rb}

@@ -4,7 +4,7 @@ require 'open3'
 
 class PgExport
   module Adapters
-    class BashAdapter
+    class ShellAdapter
       class PgRestoreError < StandardError; end
       class PgDumpError < StandardError; end
 

data/lib/pg_export/lib/pg_export/entities/dump.rb

@@ -1,17 +1,25 @@
 # frozen_string_literal: true
 
-require 'dry-initializer'
-require 'pg_export/lib/pg_export/types'
-
 class PgExport
   module Entities
     class Dump
-      extend Dry::Initializer[undefined: false]
+      attr_reader :name, :type, :database, :file
+
+      def initialize(name: nil, type: nil, database: nil, file: nil)
+        @name = String(name)
+        raise ArgumentError, 'Dump name must not be empty' if @name.empty?
+        raise ArgumentError, 'Dump name does not match criteria' unless /.+_20[0-9]{6}_[0-9]{6}\Z/.match?(@name)
 
-      option :name,     Types::DumpName
-      option :type,     Types::DumpType
-      option :database, Types::Strict::String.constrained(filled: true)
-      option :file,     Types::DumpFile, default: proc { PgExport::ValueObjects::DumpFile.new }
+        @type = String(type)
+        @type = 'plain' if @type.empty?
+        raise ArgumentError, 'Dump type must be one of: plain, encrypted' unless %w[plain encrypted].include?(@type)
+
+        @database = database
+
+        @file = file
+        @file = ValueObjects::DumpFile.new if @file.nil?
+        raise ArgumentError, "Invalid file type: #{@file.class}" unless @file.is_a?(ValueObjects::DumpFile)
+      end
 
       def encrypt(cipher_factory:)
         self.file = file.copy(cipher: cipher_factory.encryptor)
@@ -32,13 +40,17 @@ class PgExport
       end
 
       def file=(f)
-        @file = Types::DumpFile[f]
+        @file = f
+
+        raise ArgumentError, "Invalid file type: '#{f}'" unless @file.is_a?(ValueObjects::DumpFile)
       end
 
       protected
 
       def type=(t)
-        @type = Types::DumpType[t]
+        @type = t.to_s
+
+        raise ArgumentError, "Dump type '#{t}' must be one of: plain, encrypted" unless %w[plain encrypted].include?(@type)
       end
     end
   end

data/lib/pg_export/lib/pg_export/factories/cipher_factory.rb

@@ -1,12 +1,14 @@
 # frozen_string_literal: true
 
 require 'openssl'
-require 'pg_export/import'
 
 class PgExport
   module Factories
     class CipherFactory
-      include Import['config']
+      def initialize(encryption_algorithm:, encryption_key:)
+        @encryption_algorithm = encryption_algorithm
+        @encryption_key = encryption_key
+      end
 
       def encryptor
         build_cipher(:encrypt)
@@ -18,10 +20,12 @@ class PgExport
 
       private
 
+      attr_reader :encryption_algorithm, :encryption_key
+
       def build_cipher(type)
-        cipher = OpenSSL::Cipher.new(config.encryption_algorithm)
+        cipher = OpenSSL::Cipher.new(encryption_algorithm)
         cipher.public_send(type)
-        cipher.key = config.encryption_key
+        cipher.key = encryption_key
         cipher
       end
     end

data/lib/pg_export/lib/pg_export/factories/dump_factory.rb

@@ -4,7 +4,6 @@ require 'open3'
 require 'tempfile'
 
 require 'pg_export/lib/pg_export/entities/dump'
-require 'pg_export/import'
 
 class PgExport
   module Factories