eco-helpers 3.0.14 → 3.0.16

data/lib/eco/api/session/batch.rb

@@ -2,8 +2,9 @@ module Eco
   module API
     class Session
       class Batch < Common::Session::BaseSession
-        DEFAULT_BATCH_BLOCK = 50
-        VALID_METHODS = %i[get create update upsert delete].freeze
+        DEFAULT_BATCH_SIZE = 50
+        DEFAULT_JOB_SIZE   = 100
+        VALID_METHODS      = %i[get create update upsert delete].freeze
 
         class << self
           # @return [Boolean] `true` if the method is supported, `false` otherwise.
@@ -12,13 +13,19 @@ module Eco
           end
         end
 
+        def batch_size(opts = options)
+          return self.class::DEFAULT_JOB_SIZE if job_mode?(opts)
+
+          self.class::DEFAULT_BATCH_SIZE
+        end
+
         # @return [Symbol] the batch mode to run
-        def batch_mode(opts = self.options)
+        def batch_mode(opts = options)
           opts.dig(:workflow, :batch, :mode) || :batch
         end
 
         # @return [Boolean] are we running in `:job` mode?
-        def job_mode?(opts = self.options)
+        def job_mode?(opts = options)
           batch_mode(opts) == :job
         end
 
@@ -32,10 +39,16 @@ module Eco
         # @option params [String] :per_page the number of people included per each batch api request.
         # @option params [String] :q some text to search. Omit this parameter to target all the people.
         # @return [Array<People>] all the people based on `params`
-        def get_people(people = nil, params: {}, silent: false)
-          return launch(people, method: :get, params: params, silent: silent).people if people.is_a?(Enumerable)
-
-          get(params: params, silent: silent)
+        def get_people(people = nil, params: {}, silent: false, options: self.options)
+          return get(params: params, silent: silent, options: options) unless people.is_a?(Enumerable)
+
+          launch(
+            people,
+            method:  :get,
+            params:  params,
+            silent:  silent,
+            options: options
+          ).people
         end
 
         # launches a batch of `method` type using `people` and the specified `params`
@@ -47,14 +60,26 @@ module Eco
         # @param params [Hash] api request options.
         # @option params [String] :per_page the number of people included per each batch api request.
         # @return [Batch::Status] the `status` of this batch launch.
-        def launch(people, method:, params: {}, silent: false)
-          batch_from(people, method: method, params: params, silent: silent)
+        def launch(people, method:, params: {}, silent: false, options: self.options)
+          batch_from(
+            people,
+            method:  method,
+            params:  params,
+            silent:  silent,
+            options: options
+          )
         end
 
-        def search(data, silent: false, params: {}) # rubocop:disable Metrics/AbcSize
-          params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
+        def search(data, silent: false, params: {}, options: self.options) # rubocop:disable Metrics/AbcSize
+          params = {per_page: batch_size(options)}.merge(params)
 
-          launch(data, method: :get, params: params, silent: silent).tap do |status|
+          launch(
+            data,
+            method:  :get,
+            params:  params,
+            silent:  silent,
+            options: options
+          ).tap do |status|
             status.mode = :search
 
             entries = status.queue
@@ -78,7 +103,11 @@ module Eco
               people_matching = []
               email = email.to_s.strip.downcase
               unless email.empty?
-                people_matching = get(params: params.merge(q: email), silent: silent).select do |person|
+                people_matching = get(
+                  params:  params.merge(q: email),
+                  silent:  silent,
+                  options: options
+                ).select do |person|
                   person.email == email
                 end
               end
@@ -95,15 +124,21 @@ module Eco
 
         private
 
-        def get(params: {}, silent: false)
+        def get(params: {}, silent: false, options: self.options)
           msg = "cannot batch get without api connnection, please provide a valid api connection!"
           fatal msg unless (people_api = api&.people)
 
-          params = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
+          params = {per_page: batch_size(options)}.merge(params)
           people_api.get_all(params: params, silent: silent)
         end
 
-        def batch_from(data, method:, params: {}, silent: false)
+        def batch_from(
+          data,
+          method:,
+          params:  {},
+          silent:  false,
+          options: self.options
+        )
           fatal "Invalid batch method: #{method}." unless self.class.valid_method?(method)
           return nil if !data || !data.is_a?(Enumerable)
 
@@ -111,15 +146,16 @@ module Eco
           fatal msg unless (people_api = api&.people)
 
           # param q does not make sense here, even for GET method
-          params   = {per_page: DEFAULT_BATCH_BLOCK}.merge(params)
-          per_page = params[:per_page] || DEFAULT_BATCH_BLOCK
+          params   = {per_page: batch_size(options)}.merge(params)
+          per_page = params[:per_page] || batch_size(options)
 
           launch_batch(
             data,
             method:     method,
             per_page:   per_page,
             people_api: people_api,
-            silent:     silent
+            silent:     silent,
+            options:    options
           )
         end
 
@@ -128,15 +164,15 @@ module Eco
           ASSETS.cli.options
         end
 
-        def launch_batch( # rubocop:disable Metrics/AbcSize
+        def launch_batch( # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
           data,
           method:,
           status:     nil,
           job_mode:   true, # rubocop:disable Lint/UnusedMethodArgument
-          per_page:   DEFAULT_BATCH_BLOCK,
+          options:    self.options,
+          per_page:   batch_size(options),
           people_api: api&.people,
-          silent:     false,
-          options:    self.options
+          silent:     false
         )
           iteration  = 1
           done       = 0
@@ -149,17 +185,18 @@ module Eco
           )
 
           status.tap do
-            start_time  = Time.now
-            start_slice = Time.now
-
             pending_for_server_error = data.to_a[0..]
+
+            start_time = Time.now
+
             data.each_slice(per_page) do |slice|
-              msg  = "starting batch '#{method}' iteration #{iteration}/#{iterations},"
-              msg << " with #{slice.length} entries of #{data.length} -- #{done} done"
-              msg << " (last: #{str_stats(start_slice, slice.length)}; total: #{str_stats(start_time, done)})"
+              msg  = "starting batch '#{method}' iteration #{iteration}/#{iterations}, "
+              msg << "with #{slice.length} entries of #{data.length} -- #{done} done"
+              msg << (" " * 20)
               log(:info) { msg } unless silent
 
               start_slice = Time.now
+
               offer_retry_on(Ecoportal::API::Errors::TimeOut) do
                 people_api.batch(job_mode: job_mode?(options)) do |batch|
                   slice.each do |person|
@@ -175,8 +212,15 @@ module Eco
                 end # end batch
               end
 
+              done += slice.length
+
+              msg  = "  ... iteration #{iteration}/#{iterations} done "
+              msg << "in #{str_stats(start_slice, slice.length)} "
+              msg << "(average: #{str_stats(start_time, done)})"
+              msg << (" " * 20)
+              log(:info) { msg } unless silent
+
               iteration  += 1
-              done       += slice.length
             end # next slice
 
             # temporary working around (due to back-end problems with batch/jobs)
@@ -191,7 +235,8 @@ module Eco
                 job_mode:   false,
                 per_page:   per_page,
                 people_api: people_api,
-                silent:     silent
+                silent:     silent,
+                options:    options
               )
             end
           end
@@ -206,11 +251,12 @@ module Eco
         end
 
         def offer_retry_on(error_type, retries_left = 3, &block)
-          block.call
-        rescue error_type
-          raise unless retries_left.positive?
+          yield
+        rescue error_type => err
+          raise err.class, err.message, cause: nil unless retries_left.positive?
 
-          explanation = "Batch TimeOut. You have #{retries_left} retries left."
+          explanation = "#{err}\n"
+          explanation << "You have #{retries_left} retries left."
           question    = " Do you want to retry (y/N)?"
 
           prompt_user(question, default: "Y", explanation: explanation, timeout: 10) do |response|
@@ -223,7 +269,7 @@ module Eco
 
         def str_stats(start, count)
           now     = Time.now
-          secs    = (now - start).round(3)
+          secs    = (now - start).round(2)
           if secs > 0.0
             per_sec = (count.to_f / secs).round(2)
             "#{secs}s -> #{per_sec} people/s"

data/lib/eco/api/session/config/api.rb

@@ -4,6 +4,27 @@ module Eco
       class Config
         class Api < Hash
           class << self
+            def to_space(value)
+              value = value.to_s.strip.gsub(/[- ]/, '_').downcase
+              return :default if value.empty?
+
+              value.to_sym
+            end
+
+            def description(api)
+              msg = "Expecting #{self}. Given: #{api.class}"
+              raise ArgumentError, msg unless api.is_a?(self)
+
+              full_name(api.name, space: api.space)
+            end
+
+            def full_name(name, space: :default)
+              space = to_space(space)
+
+              str_space = space == :default ? '' : " (space: :#{space})"
+              "'#{name}'#{str_space}"
+            end
+
             def to_version(str)
               case str.to_sym
               when :external, :v1
@@ -35,22 +56,34 @@ module Eco
             end
           end
 
-          def initialize(name, root:, key:, host:, version:,
-            mode: :local, user_key: nil, external_key: nil,
-            email: nil, pass: nil, org_id: nil)
+          def initialize(
+            name,
+            root:,
+            key:,
+            host:,
+            version:,
+            space:        :default,
+            mode:         :local,
+            user_key:     nil,
+            external_key: nil,
+            email:        nil,
+            pass:         nil,
+            org_id:       nil
+          )
             super(nil)
-            @root = root
-            @apis = {}
-            self["name"]         = name
-            self["key"]          = key
-            self["host"]         = host
-            self["version"]      = version
-            self["mode"]         = mode
-            self["user_key"]     = user_key
-            self["external_key"] = external_key
-            self["email"]        = email || ENV['USER_EMAIL']
-            self["pass"]         = pass  || ENV['USER_PASS']
-            self["org_id"]       = org_id
+            @root                = root
+            @apis                = {}
+            self['name']         = name
+            self['space']        = to_space(space)
+            self['key']          = key
+            self['host']         = host
+            self['version']      = version
+            self['mode']         = mode
+            self['user_key']     = user_key
+            self['external_key'] = external_key
+            self['email']        = email || ENV['USER_EMAIL']
+            self['pass']         = pass  || ENV['USER_PASS']
+            self['org_id']       = org_id
           end
 
           # @return [Eco::API::Session::Config] the `root` config
@@ -67,12 +100,13 @@ module Eco
             switch_logger = (logger != @logger)
             @logger       = logger if logger
 
-            if (current = get(version)) && !switch_logger
-              return current
-            end
+            current = get(version)
+            return current if current && !switch_logger
 
             unless api_params?(version)
-              raise "The api configuration for '#{name}' is missing data for the api version '#{self.version(version)}'"
+              msg  = "The api configuration for #{description} "
+              msg << "is missing data for the api version '#{self.version(version)}'"
+              raise ArgumentError, msg
             end
 
             new_api(version).tap do |pi|
@@ -89,7 +123,16 @@ module Eco
           end
 
           def name
-            self["name"]
+            self['name']
+          end
+
+          def space
+            self['space'] ||= :default
+            to_space(self['space'])
+          end
+
+          def description
+            self.class.description(self)
           end
 
           def one_off?
@@ -97,45 +140,45 @@ module Eco
           end
 
           def key
-            self["key"]
+            self['key']
           end
 
           def user_key
-            self["user_key"] || @root.default_user_key
+            self['user_key'] || @root.default_user_key
           end
 
           def external_key
-            self["external_key"] || (%i[v1 v2].include?(version) && key)
+            self['external_key'] || (%i[v1 v2].include?(version) && key)
           end
 
           def internal_key
-            (version == :v0) && self["key"]
+            (version == :v0) && self['key']
           end
 
           def org_id
-            self["org_id"]
+            self['org_id']
           end
 
           def email
-            self["email"] || @root.default_email
+            self['email'] || @root.default_email
           end
 
           def pass
-            self["pass"] || @root.default_pass
+            self['pass'] || @root.default_pass
           end
 
           def host
-            self["host"]
+            self['host']
           end
 
           # @param mode [Symbol] to define if running on `:remote` or `:local`
           def mode=(mode)
-            self["mode"] = mode == :remote ? :remote : :local
+            self['mode'] = mode == :remote ? :remote : :local
           end
 
           # @return [Symbol] if running on `:remote` or `:local`
           def mode
-            self["mode"]
+            self['mode']
           end
 
           def local?
@@ -152,7 +195,7 @@ module Eco
           end
 
           def version(value = nil)
-            self.class.to_version(value || self["version"])
+            self.class.to_version(value || self['version'])
           end
 
           # if no low level connection messages: use `IO::NULL`
@@ -163,9 +206,14 @@ module Eco
 
           private
 
+          def to_space(...)
+            self.class.to_space(...)
+          end
+
           # Generates a **new** `API` object of version `version`.
           def new_api(version) # rubocop:disable Metrics/AbcSize
             klass = self.class.api_class(version)
+
             case self.version(version)
             when :v0
               klass.new(internal_key, host: host, logger: logger)
@@ -174,14 +222,25 @@ module Eco
             when :v2
               klass.new(user_key: user_key, org_key: external_key, host: host, logger: logger)
             when :graphql
-              kargs = {host: host, org_id: org_id, email: email, pass: pass}
+              kargs = {
+                host:   host,
+                org_id: org_id,
+                email:  email,
+                pass:   pass
+              }
+
               kargs.merge!({no_schema: true}) if ENV['GRAPHQL_FETCH_SCHEMA'] == "false"
-              klass.new(host: host, org_id: org_id, email: email, pass: pass)
+              klass.new(**kargs)
             end.tap do |api|
-              unless !api || log_connection?
-                @logger.info("Created api#{self.version(version)} connection on '#{name}' enviro, pointing to '#{host}' in '#{mode}' mode")
-                api.logger.level = ::Logger::UNKNOWN if api.respond_to?(:logger)
-              end
+              next unless api
+              next if log_connection? # prevent over-logging
+
+              msg = "Created api#{self.version(version)} connection "
+              msg << "on enviro #{description}, "
+              msg << "pointing to '#{host}' in '#{mode}' mode"
+
+              @logger.info(msg)
+              api.logger.level = ::Logger::UNKNOWN if api.respond_to?(:logger)
             end
           end
 

data/lib/eco/api/session/config/apis/enviro_spaces.rb

@@ -0,0 +1,106 @@
+module Eco
+  module API
+    class Session
+      class Config
+        class Apis
+          module EnviroSpaces
+            class << self
+              def included(base)
+                target_class = Eco::API::Session::Config::Apis
+                msg  = "To be included in #{target_class}. "
+                msg << "Included in #{base}"
+                raise msg unless base <= target_class
+
+                super
+              end
+            end
+
+            include Session::Config::Apis::SpaceHelpers
+
+            def active_space
+              active_api&.space || space_option
+            end
+
+            def enviros(space)
+              apis(space).keys
+            end
+
+            # APIs of a particualr `space`
+            def apis(space = space_option)
+              api_space(space)
+            end
+
+            # Any APIs (of any space or in a particular `space`)
+            def apis?(space = nil)
+              return apis(space).any? unless space.nil?
+
+              spaces.each_key.any? do |space|
+                apis?(space)
+              end
+            end
+
+            def api?(name, space: space_option)
+              apis(space).key?(name)
+            end
+
+            # Deprecated
+            def defined?(name, space: space_option)
+              apis(space).key?(name)
+            end
+
+            def any_defined?(*names, space: space_option)
+              [names].flatten.any? do |name|
+                api?(name, space: space)
+              end
+            end
+
+            # @return [Array<Symbol>] the spaces where the enviro `name`
+            #   has an api defined
+            def enviro_spaces(name)
+              spaces.keys.select do |space|
+                api?(name, space: space)
+              end
+            end
+
+            def enviro_spaces_str(name)
+              return '' unless enviro_spaces?(name)
+
+              ":#{enviro_spaces(name).join(', :')}"
+            end
+
+            def enviro_spaces?(name)
+              enviro_spaces(name).any?
+            end
+
+            def missing_api_message(name, space: space_option)
+              space ||= space_option
+
+              msg  = "Missing credentials for "
+              msg << "#{full_name(name, space: space)} Api env."
+
+              if enviro_spaces?(name)
+                msg << "\n  Available space(s) for '#{name}' enviro: "
+                msg << enviro_spaces_str(name)
+                msg << "\n"
+              end
+
+              msg
+            end
+
+            private
+
+            def spaces
+              self['spaces'] ||= {}
+            end
+
+            def api_space(space = space_option)
+              space ||= space_option
+
+              spaces[space.to_sym] ||= {}
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/eco/api/session/config/apis/one_off.rb

@@ -0,0 +1,94 @@
+module Eco
+  module API
+    class Session
+      class Config
+        class Apis
+          module OneOff
+            private
+
+            def one_off?
+              @is_one_off ||=
+                SCR.get_arg('-api-key') ||
+                SCR.get_arg('-one-off')
+            end
+
+            def one_off_key
+              return @one_off_key if instance_variable_defined?(:@one_off_key)
+
+              return unless one_off?
+
+              Dotenv.load('./.env_one_off')
+              SCR.get_arg('-api-key', with_param: true).then do |key|
+                one_off_key_env(key)
+              end
+            end
+
+            def one_off_key_env(key)
+              return unless one_off?
+
+              if key
+                env_file_set_var('./.env_one_off', one_off_key_env_var, key)
+                key
+              else
+                Dotenv.load('./.env_one_off')
+
+                ENV[one_off_key_env_var].tap do |k|
+                  msg  = "At least the first time, "
+                  msg << "you should provide the -api-key"
+                  raise msg unless k
+                end
+              end
+            end
+
+            def one_off_key_env_var
+              @one_off_key_env_var ||= "#{one_off_org}_KEY"
+            end
+
+            def one_off_org
+              return @one_off_org if instance_variable_defined?(:@one_off_org)
+
+              msg = "You should specify -org NAME when using -api-key or -one-off"
+              raise msg unless org = SCR.get_arg('-org', with_param: true)
+
+              str_org = "#{org.downcase.split(/[^a-z]+/).join('_')}_#{one_off_enviro.gsub('.', '_')}"
+              @one_off_org  ||= str_org.to_sym
+            end
+
+            def one_off_enviro
+              return @one_off_enviro if instance_variable_defined?(:@one_off_enviro)
+
+              enviro = 'live'
+              enviro = SCR.get_arg('-enviro', with_param: true) if SCR.get_arg('-enviro')
+
+              @one_off_enviro ||= enviro.downcase
+            end
+
+            def env_file_set_var(file, var, value)
+              pattern = /"#{var}=(?<value>[^ \r\n]+)"/
+
+              File.open(file, "w+") do |fd|
+                found = false
+
+                fd.each_line do |line|
+                  next unless (match = line.match(pattern))
+
+                  found = true
+                  #  IO::SEEK_CUR => Seeks to _amount_ plus current position
+                  fd.seek(-(line.length + 1), IO::SEEK_CUR)
+                  fd.write line.gsub(match[:value], value)
+                end
+
+                fd << "#{var}=#{value}" unless found
+              end
+
+              true
+            rescue StandardError => err
+              puts "#{err}"
+              false
+            end
+          end
+        end
+      end
+    end
+  end
+end