grumlin 0.22.4 → 1.0.0.rc1

data/lib/grumlin/repository/instance_methods.rb

@@ -1,158 +1,155 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Repository
-    module InstanceMethods # rubocop:disable Metrics/ModuleLength
-      include Grumlin::Expressions
+module Grumlin::Repository::InstanceMethods # rubocop:disable Metrics/ModuleLength
+  include Grumlin::Expressions
 
-      extend Forwardable
+  extend Forwardable
 
-      UPSERT_RETRY_PARAMS = {
-        on: [Grumlin::AlreadyExistsError, Grumlin::ConcurrentModificationError],
-        sleep_method: ->(n) { Async::Task.current.sleep(n) },
-        tries: 5,
-        sleep: ->(n) { (n**2) + 1 + rand }
-      }.freeze
+  def_delegator "self.class", :shortcuts
+  def_delegator :self, :__, :g
 
-      DEFAULT_ERROR_HANDLING_STRATEGY = ErrorHandlingStrategy.new(mode: :retry, **UPSERT_RETRY_PARAMS)
+  UPSERT_RETRY_PARAMS = {
+    on: [Grumlin::AlreadyExistsError, Grumlin::ConcurrentModificationError],
+    sleep_method: ->(n) { Async::Task.current.sleep(n) },
+    tries: 5,
+    sleep: ->(n) { (n**2) + 1 + rand }
+  }.freeze
 
-      def_delegators :shortcuts, :g, :__
+  DEFAULT_ERROR_HANDLING_STRATEGY = Grumlin::Repository::ErrorHandlingStrategy.new(mode: :retry, **UPSERT_RETRY_PARAMS)
 
-      def shortcuts
-        self.class.shortcuts
-      end
+  def __
+    shortcuts.traversal_start_class.new(pool: Grumlin.default_pool, middlewares: self.class.middlewares)
+  end
 
-      def drop_vertex(id, start: g)
-        start.V(id).drop.iterate
-      end
+  def drop_vertex(id, start: g)
+    start.V(id).drop.iterate
+  end
 
-      def drop_in_batches(traversal, batch_size: 10_000) # rubocop:disable Metrics/AbcSize
-        total_count = traversal.count.next
+  def drop_in_batches(traversal, batch_size: 10_000) # rubocop:disable Metrics/AbcSize
+    total_count = traversal.count.next
 
-        batches = (total_count / batch_size) + 1
+    batches = (total_count / batch_size) + 1
 
-        Console.logger.info(self) do
-          "drop_in_batches: total_count: #{total_count}, batch_size: #{batch_size}, batches: #{batches}"
-        end
+    Console.logger.info(self) do
+      "drop_in_batches: total_count: #{total_count}, batch_size: #{batch_size}, batches: #{batches}"
+    end
 
-        batches.times do |batch|
-          Console.logger.info(self) { "drop_in_batches: deleting batch #{batch + 1}/#{batches}..." }
-          traversal.limit(batch_size).drop.iterate
-          Console.logger.info(self) { "drop_in_batches: batch #{batch + 1}/#{batches} deleted" }
-        end
+    batches.times do |batch|
+      Console.logger.info(self) { "drop_in_batches: deleting batch #{batch + 1}/#{batches}..." }
+      traversal.limit(batch_size).drop.iterate
+      Console.logger.info(self) { "drop_in_batches: batch #{batch + 1}/#{batches} deleted" }
+    end
 
-        return if traversal.count.next.zero?
+    return if traversal.count.next.zero?
 
-        drop_in_batches(traversal, batch_size: batch_size)
+    drop_in_batches(traversal, batch_size: batch_size)
 
-        Console.logger.info(self) { "drop_in_batches: finished." }
-      end
+    Console.logger.info(self) { "drop_in_batches: finished." }
+  end
 
-      def drop_edge(id = nil, from: nil, to: nil, label: nil, start: g) # rubocop:disable Metrics/AbcSize
-        raise ArgumentError, "either id or from:, to: and label: must be passed" if [id, from, to, label].all?(&:nil?)
-        return start.E(id).drop.iterate unless id.nil?
+  def drop_edge(id = nil, from: nil, to: nil, label: nil, start: g) # rubocop:disable Metrics/AbcSize
+    raise ArgumentError, "either id or from:, to: and label: must be passed" if [id, from, to, label].all?(&:nil?)
+    return start.E(id).drop.iterate unless id.nil?
 
-        raise ArgumentError, "from:, to: and label: must be passed" if [from, to, label].any?(&:nil?)
+    raise ArgumentError, "from:, to: and label: must be passed" if [from, to, label].any?(&:nil?)
 
-        start.V(from).outE(label).where(__.inV.hasId(to)).limit(1).drop.iterate
-      end
+    start.V(from).outE(label).where(__.inV.hasId(to)).limit(1).drop.iterate
+  end
 
-      def add_vertex(label, id = nil, start: g, **properties)
-        id ||= properties[T.id]
-        properties = except(properties, T.id)
+  def add_vertex(label, id = nil, start: g, **properties)
+    id ||= properties[T.id]
+    properties = except(properties, T.id)
 
-        t = start.addV(label)
-        t = t.props(T.id => id) unless id.nil?
-        t.props(**properties).next
-      end
+    t = start.addV(label)
+    t = t.props(T.id => id) unless id.nil?
+    t.props(**properties).next
+  end
 
-      def add_edge(label, id = nil, from:, to:, start: g, **properties)
-        id ||= properties[T.id]
-        properties = except(properties, T.label)
-        properties[T.id] = id
+  def add_edge(label, id = nil, from:, to:, start: g, **properties)
+    id ||= properties[T.id]
+    properties = except(properties, T.label)
+    properties[T.id] = id
 
-        start.addE(label).from(__.V(from)).to(__.V(to)).props(**properties).next
-      end
+    start.addE(label).from(__.V(from)).to(__.V(to)).props(**properties).next
+  end
+
+  def upsert_vertex(label, id, create_properties: {}, update_properties: {}, on_failure: :retry, start: g, **params) # rubocop:disable Metrics/ParameterLists
+    with_upsert_error_handling(on_failure, params) do
+      create_properties, update_properties = cleanup_properties(create_properties, update_properties)
+
+      start.upsertV(label, id, create_properties, update_properties).id.next
+    end
+  end
 
-      def upsert_vertex(label, id, create_properties: {}, update_properties: {}, on_failure: :retry, start: g, **params) # rubocop:disable Metrics/ParameterLists
-        with_upsert_error_handling(on_failure, params) do
+  # vertices:
+  # [["label", "id", {create: :properties}, {update: properties}]]
+  # params can override Retryable config from UPSERT_RETRY_PARAMS
+  def upsert_vertices(vertices, batch_size: 100, on_failure: :retry, start: g, **params)
+    vertices.each_slice(batch_size) do |slice|
+      with_upsert_error_handling(on_failure, params) do
+        slice.reduce(start) do |t, (label, id, create_properties, update_properties)|
           create_properties, update_properties = cleanup_properties(create_properties, update_properties)
 
-          start.upsertV(label, id, create_properties, update_properties).id.next
-        end
+          t.upsertV(label, id, create_properties, update_properties)
+        end.id.iterate
       end
+    end
+  end
 
-      # vertices:
-      # [["label", "id", {create: :properties}, {update: properties}]]
-      # params can override Retryable config from UPSERT_RETRY_PARAMS
-      def upsert_vertices(vertices, batch_size: 100, on_failure: :retry, start: g, **params)
-        vertices.each_slice(batch_size) do |slice|
-          with_upsert_error_handling(on_failure, params) do
-            slice.reduce(start) do |t, (label, id, create_properties, update_properties)|
-              create_properties, update_properties = cleanup_properties(create_properties, update_properties)
-
-              t.upsertV(label, id, create_properties, update_properties)
-            end.id.iterate
-          end
-        end
-      end
+  # Only from and to are used to find the existing edge, if one wants to assign an id to a created edge,
+  # it must be passed as T.id in create_properties.
+  def upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}, # rubocop:disable Metrics/ParameterLists
+                  on_failure: :retry, start: g, **params)
+    with_upsert_error_handling(on_failure, params) do
+      create_properties, update_properties = cleanup_properties(create_properties, update_properties, T.label)
+      start.upsertE(label, from, to, create_properties, update_properties).id.next
+    end
+  end
 
-      # Only from and to are used to find the existing edge, if one wants to assign an id to a created edge,
-      # it must be passed as T.id in create_properties.
-      def upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}, # rubocop:disable Metrics/ParameterLists
-                      on_failure: :retry, start: g, **params)
-        with_upsert_error_handling(on_failure, params) do
+  # edges:
+  # [["label", "from", "to", {create: :properties}, {update: properties}]]
+  # params can override Retryable config from UPSERT_RETRY_PARAMS
+  def upsert_edges(edges, batch_size: 100, on_failure: :retry, start: g, **params)
+    edges.each_slice(batch_size) do |slice|
+      with_upsert_error_handling(on_failure, params) do
+        slice.reduce(start) do |t, (label, from, to, create_properties, update_properties)|
           create_properties, update_properties = cleanup_properties(create_properties, update_properties, T.label)
-          start.upsertE(label, from, to, create_properties, update_properties).id.next
-        end
-      end
 
-      # edges:
-      # [["label", "from", "to", {create: :properties}, {update: properties}]]
-      # params can override Retryable config from UPSERT_RETRY_PARAMS
-      def upsert_edges(edges, batch_size: 100, on_failure: :retry, start: g, **params)
-        edges.each_slice(batch_size) do |slice|
-          with_upsert_error_handling(on_failure, params) do
-            slice.reduce(start) do |t, (label, from, to, create_properties, update_properties)|
-              create_properties, update_properties = cleanup_properties(create_properties, update_properties, T.label)
-
-              t.upsertE(label, from, to, create_properties, update_properties)
-            end.id.iterate
-          end
-        end
+          t.upsertE(label, from, to, create_properties, update_properties)
+        end.id.iterate
       end
+    end
+  end
 
-      private
+  private
 
-      def with_upsert_error_handling(on_failure, params, &block)
-        if params.any?
-          ErrorHandlingStrategy.new(mode: on_failure, **UPSERT_RETRY_PARAMS.merge(params))
-        else
-          DEFAULT_ERROR_HANDLING_STRATEGY
-        end.apply!(&block)
-      end
+  def with_upsert_error_handling(on_failure, params, &block)
+    if params.any?
+      ErrorHandlingStrategy.new(mode: on_failure, **UPSERT_RETRY_PARAMS.merge(params))
+    else
+      DEFAULT_ERROR_HANDLING_STRATEGY
+    end.apply!(&block)
+  end
 
-      def with_upsert_retry(retry_params, &block)
-        retry_params = UPSERT_RETRY_PARAMS.merge((retry_params))
-        Retryable.retryable(**retry_params, &block)
-      end
+  def with_upsert_retry(retry_params, &block)
+    retry_params = UPSERT_RETRY_PARAMS.merge((retry_params))
+    Retryable.retryable(**retry_params, &block)
+  end
 
-      # A polyfill for Hash#except for ruby 2.x environments without ActiveSupport
-      # TODO: delete and use native Hash#except after ruby 2.7 is deprecated.
-      def except(hash, *keys)
-        return hash.except(*keys) if hash.respond_to?(:except)
+  # A polyfill for Hash#except for ruby 2.x environments without ActiveSupport
+  # TODO: delete and use native Hash#except after ruby 2.7 is deprecated.
+  def except(hash, *keys)
+    return hash.except(*keys) if hash.respond_to?(:except)
 
-        hash.each_with_object({}) do |(k, v), res|
-          res[k] = v unless keys.include?(k)
-        end
-      end
+    hash.each_with_object({}) do |(k, v), res|
+      res[k] = v unless keys.include?(k)
+    end
+  end
 
-      def cleanup_properties(create_properties, update_properties, *props_to_cleanup)
-        props_to_cleanup = [T.id, T.label] if props_to_cleanup.empty?
-        [create_properties, update_properties].map do |props|
-          except(props, props_to_cleanup)
-        end
-      end
+  def cleanup_properties(create_properties, update_properties, *props_to_cleanup)
+    props_to_cleanup = [T.id, T.label] if props_to_cleanup.empty?
+    [create_properties, update_properties].map do |props|
+      except(props, props_to_cleanup)
     end
   end
 end

data/lib/grumlin/repository.rb

@@ -1,83 +1,107 @@
 # frozen_string_literal: true
 
-module Grumlin
-  module Repository
-    RETURN_MODES = {
-      list: :toList,
-      none: :iterate,
-      single: :next,
-      traversal: :nil
-    }.freeze
-
-    def self.extended(base)
-      super
-      base.extend(Grumlin::Shortcuts)
-      base.include(Repository::InstanceMethods)
-
-      base.shortcuts_from(Grumlin::Shortcuts::Properties)
-      base.shortcuts_from(Grumlin::Shortcuts::Upserts)
+module Grumlin::Repository
+  RETURN_MODES = {
+    list: :toList,
+    none: :iterate,
+    single: :next,
+    traversal: :nil
+  }.freeze
+
+  def self.extended(base)
+    super
+    base.extend(Grumlin::Shortcuts)
+    base.include(Grumlin::Repository::InstanceMethods)
+
+    base.shortcuts_from(Grumlin::Shortcuts::Properties)
+    base.shortcuts_from(Grumlin::Shortcuts::Upserts)
+  end
+
+  def self.new
+    @repository ||= Class.new do # rubocop:disable Naming/MemoizedInstanceVariableName
+      extend Grumlin::Repository
+    end.new
+  end
+
+  def inherited(subclass)
+    super
+    subclass.middlewares = Grumlin::Middlewares::Builder.new do |b|
+      b.use(middlewares)
     end
+  end
 
-    def self.new
-      @repository ||= Class.new do # rubocop:disable Naming/MemoizedInstanceVariableName
-        extend Grumlin::Repository
-      end.new
+  def read_only!
+    middlewares do |b|
+      b.insert_after Grumlin::Middlewares::ApplyShortcuts, Grumlin::Middlewares::FindMutatingSteps
     end
+  end
 
-    def query(name, return_mode: :list, postprocess_with: nil, &query_block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
-      return_mode = validate_return_mode!(return_mode)
-      postprocess_with = validate_postprocess_with!(postprocess_with)
+  def middlewares
+    @middlewares ||= Grumlin::Middlewares::Builder.new do |b|
+      b.use(Grumlin.default_middlewares)
+    end
 
-      define_method name do |*args, query_params: {}, **params, &block|
-        t = instance_exec(*args, **params, &query_block)
-        return t if t.nil? || (t.respond_to?(:empty?) && t.empty?)
+    yield(@middlewares) if block_given?
+    @middlewares
+  end
 
-        unless t.is_a?(Grumlin::Action)
-          raise WrongQueryResult,
-                "queries must return #{Grumlin::Action}, nil or an empty collection. Given: #{t.class}"
-        end
+  def query(name, return_mode: :list, postprocess_with: nil, &query_block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity
+    return_mode = validate_return_mode!(return_mode)
+    postprocess_with = validate_postprocess_with!(postprocess_with)
 
-        return block.call(t) unless block.nil?
+    define_method name do |*args, query_params: {}, **params, &block|
+      t = instance_exec(*args, **params, &query_block)
+      return t if t.nil? || (t.respond_to?(:empty?) && t.empty?)
 
-        return t.profile.next if query_params[:profile] == true
+      unless t.is_a?(Grumlin::Step)
+        raise Grumlin::WrongQueryResult,
+              "queries must return #{Grumlin::Step}, nil or an empty collection. Given: #{t.class}"
+      end
 
-        return_mode = self.class.validate_return_mode!(query_params[:return_mode] || return_mode)
+      return block.call(t) unless block.nil?
 
-        return t if return_mode == :traversal
+      return t.profile.next if query_params[:profile] == true
 
-        t.public_send(RETURN_MODES[return_mode]).tap do |result|
-          return postprocess_with.call(result) if postprocess_with.respond_to?(:call)
-          return send(postprocess_with, result) unless postprocess_with.nil?
-        end
-      end
-    end
+      return_mode = self.class.validate_return_mode!(query_params[:return_mode] || return_mode)
 
-    def default_vertex_properties(&block)
-      shortcut :addV, override: true do |*args|
-        super(*args).props(**block.call(*args)) # rubocop:disable Performance/RedundantBlockCall
-      end
-    end
+      return t if return_mode == :traversal
 
-    def default_edge_properties(&block)
-      shortcut :addE, override: true do |*args|
-        super(*args).props(**block.call(*args))  # rubocop:disable Performance/RedundantBlockCall
+      t.public_send(RETURN_MODES[return_mode]).tap do |result|
+        return postprocess_with.call(result) if postprocess_with.respond_to?(:call)
+        return send(postprocess_with, result) unless postprocess_with.nil?
       end
     end
+  end
 
-    def validate_return_mode!(return_mode)
-      return return_mode if RETURN_MODES.include?(return_mode)
+  def default_vertex_properties(&block)
+    shortcut :addV, override: true do |*args|
+      super(*args).props(**block.call(*args)) # rubocop:disable Performance/RedundantBlockCall
+    end
+  end
 
-      raise ArgumentError, "unsupported return mode #{return_mode}. Supported modes: #{RETURN_MODES.keys}"
+  def default_edge_properties(&block)
+    shortcut :addE, override: true do |*args|
+      super(*args).props(**block.call(*args))  # rubocop:disable Performance/RedundantBlockCall
     end
+  end
 
-    def validate_postprocess_with!(postprocess_with)
-      if postprocess_with.nil? || postprocess_with.is_a?(Symbol) ||
-         postprocess_with.is_a?(String) || postprocess_with.respond_to?(:call)
-        return postprocess_with
-      end
+  def validate_return_mode!(return_mode)
+    return return_mode if RETURN_MODES.include?(return_mode)
 
-      raise ArgumentError,
-            "postprocess_with must be a String, Symbol or a callable object, given: #{postprocess_with.class}"
+    raise ArgumentError, "unsupported return mode #{return_mode}. Supported modes: #{RETURN_MODES.keys}"
+  end
+
+  def validate_postprocess_with!(postprocess_with)
+    if postprocess_with.nil? || postprocess_with.is_a?(Symbol) ||
+       postprocess_with.is_a?(String) || postprocess_with.respond_to?(:call)
+      return postprocess_with
     end
+
+    raise ArgumentError,
+          "postprocess_with must be a String, Symbol or a callable object, given: #{postprocess_with.class}"
   end
+
+  protected
+
+  attr_writer :middlewares
 end

data/lib/grumlin/request_dispatcher.rb

@@ -1,80 +1,78 @@
 # frozen_string_literal: true
 
-module Grumlin
-  class RequestDispatcher
-    attr_reader :requests
+class Grumlin::RequestDispatcher
+  attr_reader :requests
 
-    SUCCESS = {
-      200 => :success,
-      204 => :no_content,
-      206 => :partial_content
-    }.freeze
+  SUCCESS = {
+    200 => :success,
+    204 => :no_content,
+    206 => :partial_content
+  }.freeze
 
-    class DispatcherError < Grumlin::Error; end
+  class DispatcherError < Grumlin::Error; end
 
-    class RequestAlreadyAddedError < DispatcherError; end
+  class RequestAlreadyAddedError < DispatcherError; end
 
-    class UnknownRequestError < DispatcherError; end
+  class UnknownRequestError < DispatcherError; end
 
-    def initialize
-      @requests = {}
+  def initialize
+    @requests = {}
+  end
+
+  def add_request(request)
+    raise RequestAlreadyAddedError if @requests.include?(request[:requestId])
+
+    Async::Channel.new.tap do |channel|
+      @requests[request[:requestId]] = { request: request, result: [], channel: channel }
     end
+  end
 
-    def add_request(request)
-      raise RequestAlreadyAddedError if @requests.include?(request[:requestId])
+  # builds a response object, when it's ready sends it to the client via a channel
+  # TODO: sometimes response does not include requestID, no idea how to handle it so far.
+  def add_response(response) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
+    request_id = response[:requestId]
+    raise UnknownRequestError unless ongoing_request?(request_id)
 
-      Async::Channel.new.tap do |channel|
-        @requests[request[:requestId]] = { request: request, result: [], channel: channel }
+    begin
+      request = @requests[request_id]
+
+      Grumlin::RequestErrorFactory.build(request, response).tap do |err|
+        raise err unless err.nil?
       end
-    end
 
-    # builds a response object, when it's ready sends it to the client via a channel
-    # TODO: sometimes response does not include requestID, no idea how to handle it so far.
-    def add_response(response) # rubocop:disable Metrics/AbcSize, Metrics/MethodLength
-      request_id = response[:requestId]
-      raise UnknownRequestError unless ongoing_request?(request_id)
-
-      begin
-        request = @requests[request_id]
-
-        RequestErrorFactory.build(request, response).tap do |err|
-          raise err unless err.nil?
-        end
-
-        case SUCCESS[response.dig(:status, :code)]
-        when :success
-          request[:result] << response.dig(:result, :data)
-          request[:channel] << request[:result]
-          close_request(request_id)
-        when :partial_content then request[:result] << response.dig(:result, :data)
-        when :no_content
-          request[:channel] << []
-          close_request(request_id)
-        end
-      rescue StandardError => e
-        request[:channel].exception(e)
+      case SUCCESS[response.dig(:status, :code)]
+      when :success
+        request[:result] << response.dig(:result, :data)
+        request[:channel] << request[:result]
+        close_request(request_id)
+      when :partial_content then request[:result] << response.dig(:result, :data)
+      when :no_content
+        request[:channel] << []
         close_request(request_id)
       end
+    rescue StandardError => e
+      request[:channel].exception(e)
+      close_request(request_id)
     end
+  end
 
-    def ongoing_request?(request_id)
-      @requests.include?(request_id)
-    end
+  def ongoing_request?(request_id)
+    @requests.include?(request_id)
+  end
 
-    def clear
-      @requests.each do |_id, request|
-        request[:channel].close!
-      end
-      @requests.clear
+  def clear
+    @requests.each do |_id, request|
+      request[:channel].close!
     end
+    @requests.clear
+  end
 
-    private
+  private
 
-    def close_request(request_id)
-      raise UnknownRequestError unless ongoing_request?(request_id)
+  def close_request(request_id)
+    raise UnknownRequestError unless ongoing_request?(request_id)
 
-      request = @requests.delete(request_id)
-      request[:channel].close
-    end
+    request = @requests.delete(request_id)
+    request[:channel].close
   end
 end