grumlin 0.18.1 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 573e2c9cda13465c0560d36e9e10d8bcdda5e0ea01ea4bbf89cb8d6cb943f6de
-  data.tar.gz: 8dd6fa7264875f372c6117352f2e87c7984457ff3f94da57f8f19d91344c4dd2
+  metadata.gz: f899b66f4f483334c271ca60f6ade26d5b403bc10552e03700595e983e0268cb
+  data.tar.gz: ea689ad161f0b220e37af0fd5aa32adaa50990ebdcdc6d8e8cef7b12b53067e5
 SHA512:
-  metadata.gz: 2eea2219d92cd29ef311993dcd0bcd0e9d8906d39474d93733c8406952e93babf85d4468b6acd15ac1d114c940c49533603960fa496c8f757223d016b5619a03
-  data.tar.gz: 39c8821a89cb1194d973c7b2dee5e96ad90288e2a611ef42a080586987759949453a2c7bade5be56d500588a8655a485c6c415c075c1295534bbc8a419bf2d43
+  metadata.gz: f9d3c770966a9f44efc25c7f7ad3a33203daafc0e1f3887db22ef6cd9c37415073c72cb90dd7cb7658c12a5e9ac2aa587c48d590ff417a7ba4c26b1f2586214d
+  data.tar.gz: 5a9ed3d9e7ff5c717083b5d36b8de17a4ef8b3ed4310c67b35b8ff56d5f7b49e2d74770e47cd1aa96f3544549f9fad9ddba5bf5695ca4bf9e23c04bb4d15f90b

data/.gitignore

@@ -10,3 +10,5 @@
 
 # rspec failure tracking
 .rspec_status
+profile.flat.txt
+profile.graph.html

data/.rubocop.yml

@@ -15,6 +15,7 @@ Layout/LineLength:
 Metrics/BlockLength:
   Exclude:
     - spec/**/*_spec.rb
+    - "*.gemspec"
 
 Metrics/MethodLength:
   Max: 20

data/Gemfile

@@ -17,3 +17,7 @@ gem "overcommit"
 gem "rake"
 gem "rspec"
 gem "simplecov"
+
+gem "benchmark-ips"
+gem "memory_profiler"
+gem "ruby-prof"

data/Gemfile.lock

@@ -1,10 +1,11 @@
 PATH
   remote: .
   specs:
-    grumlin (0.18.1)
+    grumlin (0.19.0)
       async-pool (~> 0.3)
       async-websocket (~> 0.19)
       oj (~> 3.12)
+      retryable (~> 3.0)
       zeitwerk (~> 2.4)
 
 GEM
@@ -21,13 +22,14 @@ GEM
       console (~> 1.10)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-http (0.56.5)
+    async-http (0.56.6)
       async (>= 1.25)
       async-io (>= 1.28)
       async-pool (>= 0.2)
       protocol-http (~> 0.22.0)
       protocol-http1 (~> 0.14.0)
       protocol-http2 (~> 0.14.0)
+      traces (~> 0.4.0)
     async-io (1.33.0)
       async
     async-pool (0.3.9)
@@ -42,6 +44,7 @@ GEM
       protocol-websocket (~> 0.7.0)
     backport (1.2.0)
     benchmark (0.1.1)
+    benchmark-ips (2.10.0)
     childprocess (4.0.0)
     concurrent-ruby (1.1.8)
     console (1.15.0)
@@ -60,6 +63,7 @@ GEM
       rexml
     kramdown-parser-gfm (1.1.0)
       kramdown (~> 2.0)
+    memory_profiler (1.0.0)
     mini_portile2 (2.7.1)
     minitest (5.14.4)
     nio4r (2.5.8)
@@ -76,8 +80,8 @@ GEM
     parser (3.0.3.2)
       ast (~> 2.4.1)
     protocol-hpack (1.4.2)
-    protocol-http (0.22.5)
-    protocol-http1 (0.14.2)
+    protocol-http (0.22.6)
+    protocol-http1 (0.14.4)
       protocol-http (~> 0.22)
     protocol-http2 (0.14.2)
       protocol-hpack (~> 1.4)
@@ -89,6 +93,7 @@ GEM
     rainbow (3.0.0)
     rake (13.0.3)
     regexp_parser (2.2.0)
+    retryable (3.0.5)
     reverse_markdown (2.0.0)
       nokogiri
     rexml (3.2.5)
@@ -125,6 +130,7 @@ GEM
       rubocop-ast (>= 0.4.0)
     rubocop-rspec (2.6.0)
       rubocop (~> 1.19)
+    ruby-prof (1.4.3)
     ruby-progressbar (1.11.0)
     simplecov (0.21.2)
       docile (~> 1.1)
@@ -150,6 +156,7 @@ GEM
     thor (1.1.0)
     tilt (2.0.10)
     timers (4.3.3)
+    traces (0.4.1)
     tzinfo (2.0.4)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.1.0)
@@ -162,8 +169,10 @@ PLATFORMS
 
 DEPENDENCIES
   async-rspec
+  benchmark-ips
   factory_bot
   grumlin!
+  memory_profiler
   nokogiri
   overcommit
   rake
@@ -171,6 +180,7 @@ DEPENDENCIES
   rubocop
   rubocop-performance
   rubocop-rspec
+  ruby-prof
   simplecov
   solargraph
 

data/README.md

@@ -188,8 +188,16 @@ Each `return_mode` is mapped to a particular termination step:
 - `add_edge(label, id = nil, from:, to:, **properties)`
 - `drop_vertex(id)`
 - `drop_edge(id = nil, from: nil, to: nil, label: nil)`
-- `upsert_vertex(label, id, create_properties: {}, update_properties: {})`
-- `upsert_edge(label, from:, to:, create_properties: {}, update_properties: {})`
+
+and a few methods that emulate upserts:
+- `upsert_vertex(label, id, create_properties: {}, update_properties: {}, on_failure: :retry, **params)` 
+- `upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}, on_failure: :retry, **params)`
+- `upsert_edges(edges, batch_size: 100, on_failure: :retry, **params)`
+- `upsert_vertices(edges, batch_size: 100, on_failure: :retry, **params)`
+
+All of them support 3 different modes for error handling: `:retry`, `:ignore` and `:raise`. Retry mode is implemented
+with [retryable](https://github.com/nfedyashev/retryable). **params will be merged to the default config for upserts 
+and passed to `Retryable.retryable`. In case if you want to modify retryable behaviour you are to do so.
 
 **Usage**
 

data/grumlin.gemspec

@@ -30,6 +30,7 @@ Gem::Specification.new do |spec|
   spec.add_dependency "async-pool", "~> 0.3"
   spec.add_dependency "async-websocket", "~> 0.19"
   spec.add_dependency "oj", "~> 3.12"
+  spec.add_dependency "retryable", "~> 3.0"
   spec.add_dependency "zeitwerk", "~> 2.4"
   spec.metadata = {
     "rubygems_mfa_required" => "true"

data/lib/async/channel.rb

@@ -18,6 +18,10 @@ module Async
       @closed
     end
 
+    def open?
+      !@closed
+    end
+
     # Methods for a publisher
     def <<(payload)
       raise(ChannelClosedError, "Cannot send to a closed channel") if @closed
@@ -38,6 +42,13 @@ module Async
       @closed = true
     end
 
+    def close!
+      return if closed?
+
+      exception(ChannelClosedError.new("Channel was forcefully closed"))
+      close
+    end
+
     # Methods for a subscriber
     def dequeue
       each do |payload| # rubocop:disable Lint/UnreachableLoop this is intended

data/lib/grumlin/repository/error_handling_strategy.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Repository
+    class ErrorHandlingStrategy
+      def initialize(mode: :retry, **params)
+        @mode = mode
+        @params = params
+        @on_exceptions = params[:on]
+      end
+
+      def raise?
+        @mode == :raise
+      end
+
+      def ignore?
+        @mode == :ignore
+      end
+
+      def retry?
+        @mode == :retry
+      end
+
+      def apply!(&block)
+        return yield if raise?
+        return ignore_errors!(&block) if ignore?
+
+        retry_errors!(&block)
+      end
+
+      private
+
+      def ignore_errors!
+        yield
+      rescue *@on_exceptions
+        # ignore errors
+      end
+
+      def retry_errors!(&block)
+        Retryable.retryable(**@params, &block)
+      end
+    end
+  end
+end

data/lib/grumlin/repository/instance_methods.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Repository
+    module InstanceMethods
+      include Grumlin::Expressions
+
+      UPSERT_RETRY_PARAMS = {
+        on: [Grumlin::AlreadyExistsError, Grumlin::ConcurrentInsertFailedError],
+        sleep_method: ->(n) { Async::Task.current.sleep(n) },
+        tries: 3,
+        sleep: ->(n) { (n**2) + 1 + rand }
+      }.freeze
+
+      DEFAULT_ERROR_HANDLING_STRATEGY = ErrorHandlingStrategy.new(mode: :retry, **UPSERT_RETRY_PARAMS)
+
+      def __
+        @__ ||= TraversalStart.new(self.class.shortcuts)
+      end
+
+      def g
+        @g ||= TraversalStart.new(self.class.shortcuts)
+      end
+
+      def drop_vertex(id)
+        g.V(id).drop.iterate
+      end
+
+      def drop_edge(id = nil, from: nil, to: nil, label: nil) # rubocop:disable Metrics/AbcSize
+        raise ArgumentError, "either id or from:, to: and label: must be passed" if [id, from, to, label].all?(&:nil?)
+        return g.E(id).drop.iterate unless id.nil?
+
+        raise ArgumentError, "from:, to: and label: must be passed" if [from, to, label].any?(&:nil?)
+
+        g.V(from).outE(label).where(__.inV.hasId(to)).limit(1).drop.iterate
+      end
+
+      def add_vertex(label, id = nil, **properties)
+        id ||= properties[T.id]
+        properties = except(properties, T.id)
+
+        t = g.addV(label)
+        t = t.props(T.id => id) unless id.nil?
+        t.props(**properties).next
+      end
+
+      def add_edge(label, id = nil, from:, to:, **properties)
+        id ||= properties[T.id]
+        properties = except(properties, T.label)
+        properties[T.id] = id
+
+        g.addE(label).from(__.V(from)).to(__.V(to)).props(**properties).next
+      end
+
+      def upsert_vertex(label, id, create_properties: {}, update_properties: {}, on_failure: :retry, **params)
+        with_upsert_error_handling(on_failure, params) do
+          create_properties, update_properties = cleanup_properties(create_properties, update_properties)
+
+          g.upsertV(label, id, create_properties, update_properties).next
+        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, **params)
+        with_upsert_error_handling(on_failure, params) do
+          vertices.each_slice(batch_size) do |slice|
+            slice.reduce(g) 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.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: {}, on_failure: :retry, **params) # rubocop:disable Metrics/ParameterLists
+        with_upsert_error_handling(on_failure, params) do
+          create_properties, update_properties = cleanup_properties(create_properties, update_properties, T.label)
+          g.upsertE(label, from, to, create_properties, update_properties).next
+        end
+      end
+
+      # edges:
+      # [["label", "id", {create: :properties}, {update: properties}]]
+      # params can override Retryable config from UPSERT_RETRY_PARAMS
+      def upsert_edges(edges, batch_size: 100, on_failure: :retry, **params)
+        with_upsert_error_handling(on_failure, params) do
+          edges.each_slice(batch_size) do |slice|
+            slice.reduce(g) 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.iterate
+          end
+        end
+      end
+
+      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_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)
+
+        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
+    end
+  end
+end

data/lib/grumlin/repository.rb

@@ -9,92 +9,12 @@ module Grumlin
       traversal: :nil
     }.freeze
 
-    module InstanceMethods
-      include Grumlin::Expressions
-
-      def __
-        TraversalStart.new(self.class.shortcuts)
-      end
-
-      def g
-        TraversalStart.new(self.class.shortcuts)
-      end
-
-      def drop_vertex(id)
-        g.V(id).drop.iterate
-      end
-
-      def drop_edge(id = nil, from: nil, to: nil, label: nil) # rubocop:disable Metrics/AbcSize
-        raise ArgumentError, "either id or from:, to: and label: must be passed" if [id, from, to, label].all?(&:nil?)
-        return g.E(id).drop.iterate unless id.nil?
-
-        raise ArgumentError, "from:, to: and label: must be passed" if [from, to, label].any?(&:nil?)
-
-        g.V(from).outE(label).where(__.inV.hasId(to)).limit(1).drop.iterate
-      end
-
-      def add_vertex(label, id = nil, **properties)
-        id ||= properties[T.id]
-        properties = except(properties, T.id)
-
-        t = g.addV(label)
-        t = t.props(T.id => id) unless id.nil?
-        t.props(**properties).next
-      end
-
-      def add_edge(label, id = nil, from:, to:, **properties)
-        id ||= properties[T.id]
-        properties = except(properties, T.label)
-        properties[T.id] = id
-
-        g.addE(label).from(__.V(from)).to(__.V(to)).props(**properties).next
-      end
-
-      def upsert_vertex(label, id, create_properties: {}, update_properties: {}) # rubocop:disable Metrics/AbcSize
-        create_properties = except(create_properties, T.id, T.label)
-        update_properties = except(update_properties, T.id, T.label)
-        g.V(id)
-         .fold
-         .coalesce(
-           __.unfold,
-           __.addV(label).props(**create_properties.merge(T.id => id))
-         ).props(**update_properties)
-         .next
-      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 via create_properties.
-      def upsert_edge(label, from:, to:, create_properties: {}, update_properties: {}) # rubocop:disable Metrics/AbcSize
-        create_properties = except(create_properties, T.label)
-        update_properties = except(update_properties, T.id, T.label)
-
-        g.V(from)
-         .outE(label).where(__.inV.hasId(to))
-         .fold
-         .coalesce(
-           __.unfold,
-           __.addE(label).from(__.V(from)).to(__.V(to)).props(**create_properties)
-         ).props(**update_properties).next
-      end
-
-      private
-
-      # A polyfill for Hash#except for ruby 2.x environments without ActiveSupport
-      # TODO: delete and use native Hash#except when 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
-    end
-
     def self.extended(base)
       base.extend(Grumlin::Shortcuts)
-      base.include(InstanceMethods)
+      base.include(Repository::InstanceMethods)
 
       base.shortcuts_from(Grumlin::Shortcuts::Properties)
+      base.shortcuts_from(Grumlin::Shortcuts::Upserts)
     end
 
     def query(name, return_mode: :list, postprocess_with: nil, &query_block) # rubocop:disable Metrics/AbcSize, Metrics/CyclomaticComplexity, Metrics/PerceivedComplexity

data/lib/grumlin/request_dispatcher.rb

@@ -22,6 +22,11 @@ module Grumlin
       498 => ClientSideError
     }.freeze
 
+    VERTEX_ALREADY_EXISTS = "Vertex with id already exists:"
+    EDGE_ALREADY_EXISTS = "Edge with id already exists:"
+    CONCURRENT_VERTEX_INSERT_FAILED = "Failed to complete Insert operation for a Vertex due to conflicting concurrent"
+    CONCURRENT_EDGE_INSERT_FAILED = "Failed to complete Insert operation for an Edge due to conflicting concurrent"
+
     class DispatcherError < Grumlin::Error; end
 
     class RequestAlreadyAddedError < DispatcherError; end
@@ -46,29 +51,25 @@ module Grumlin
       request_id = response[:requestId]
       raise UnknownRequestError unless ongoing_request?(request_id)
 
-      request = @requests[request_id]
-
-      check_errors!(response[:status], request[:request])
-
-      case SUCCESS[response.dig(:status, :code)]
-      when :success
-        request[:channel] << [*request[:result], response.dig(:result, :data)]
-        close_request(request_id)
-      when :partial_content then request[:result] << response.dig(:result, :data)
-      when :no_content
-        request[:channel] << []
+      begin
+        request = @requests[request_id]
+
+        check_errors!(response[:status], request[:request])
+
+        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
-    rescue StandardError => e
-      request[:channel].exception(e)
-      close_request(request_id)
-    end
-
-    def close_request(request_id)
-      raise UnknownRequestError unless ongoing_request?(request_id)
-
-      request = @requests.delete(request_id)
-      request[:channel].close
     end
 
     def ongoing_request?(request_id)
@@ -76,19 +77,43 @@ module Grumlin
     end
 
     def clear
+      @requests.each do |_id, request|
+        request[:channel].close!
+      end
       @requests.clear
     end
 
     private
 
+    def close_request(request_id)
+      raise UnknownRequestError unless ongoing_request?(request_id)
+
+      request = @requests.delete(request_id)
+      request[:channel].close
+    end
+
     def check_errors!(status, query)
       if (error = ERRORS[status[:code]])
-        raise error.new(status, query)
+        raise (
+          already_exists_error(status) ||
+          concurrent_insert_error(status) ||
+          error
+        ).new(status, query)
       end
 
       return unless SUCCESS[status[:code]].nil?
 
       raise(UnknownResponseStatus, status)
     end
+
+    def already_exists_error(status)
+      return VertexAlreadyExistsError if status[:message].include?(VERTEX_ALREADY_EXISTS)
+      return EdgeAlreadyExistsError if status[:message].include?(EDGE_ALREADY_EXISTS)
+    end
+
+    def concurrent_insert_error(status)
+      return ConcurrentVertexInsertFailedError if status[:message].include?(CONCURRENT_VERTEX_INSERT_FAILED)
+      return ConcurrentEdgeInsertFailedError if status[:message].include?(CONCURRENT_EDGE_INSERT_FAILED)
+    end
   end
 end

data/lib/grumlin/shortcuts/properties.rb

@@ -6,8 +6,10 @@ module Grumlin
       extend Grumlin::Shortcuts
 
       shortcut :props do |**props|
-        props.compact.reduce(self) do |tt, (prop, value)|
-          tt.property(prop, value)
+        props.reduce(self) do |tt, (prop, value)| # rubocop:disable Style/EachWithObject
+          next tt.property(prop, value) unless value.nil? # nils are not supported
+
+          tt
         end
       end
 

data/lib/grumlin/shortcuts/upserts.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Shortcuts
+    module Upserts
+      extend Grumlin::Shortcuts
+
+      shortcut :upsertV do |label, id, create_properties, update_properties|
+        self.V(id)
+            .fold
+            .coalesce( # TODO: extract upsert pattern to a shortcut
+              __.unfold,
+              __.addV(label).props(**create_properties.merge(T.id => id))
+            ).props(**update_properties)
+      end
+
+      shortcut :upsertE do |label, from, to, create_properties, update_properties|
+        self.V(from)
+            .outE(label).where(__.inV.hasId(to))
+            .fold
+            .coalesce(
+              __.unfold,
+              __.addE(label).from(__.V(from)).to(__.V(to)).props(**create_properties)
+            ).props(**update_properties)
+      end
+    end
+  end
+end

data/lib/grumlin/shortcuts_applyer.rb

@@ -4,43 +4,39 @@ module Grumlin
   class ShortcutsApplyer
     class << self
       def call(steps)
-        new.call(steps)
-      end
-    end
+        return steps unless steps.uses_shortcuts?
 
-    def call(steps)
-      return steps unless steps.uses_shortcuts?
+        shortcuts = steps.shortcuts
 
-      shortcuts = steps.shortcuts
+        configuration_steps = process_steps(steps.configuration_steps, shortcuts)
+        regular_steps = process_steps(steps.steps, shortcuts)
 
-      configuration_steps = process_steps(steps.configuration_steps, shortcuts)
-      regular_steps = process_steps(steps.steps, shortcuts)
-
-      Steps.new(shortcuts).tap do |processed_steps|
-        (configuration_steps + regular_steps).each do |step|
-          processed_steps.add(step.name, args: step.args, params: step.params)
+        Steps.new(shortcuts).tap do |processed_steps|
+          (configuration_steps + regular_steps).each do |step|
+            processed_steps.add(step.name, args: step.args, params: step.params)
+          end
         end
       end
-    end
-
-    private
-
-    def process_steps(steps, shortcuts) # rubocop:disable Metrics/AbcSize
-      steps.each_with_object([]) do |step, result|
-        args = step.args.map do |arg|
-          arg.is_a?(Steps) ? ShortcutsApplyer.call(arg) : arg
-        end
-
-        if shortcuts.include?(step.name)
-          t = TraversalStart.new(shortcuts)
-          action = shortcuts[step.name].apply(t, *args, **step.params)
-          next if action.nil? || action == t # Shortcut did not add any steps
 
-          new_steps = ShortcutsApplyer.call(Steps.from(action))
-          result.concat(new_steps.configuration_steps)
-          result.concat(new_steps.steps)
-        else
-          result << StepData.new(step.name, args: args, params: step.params)
+      private
+
+      def process_steps(steps, shortcuts) # rubocop:disable Metrics/AbcSize
+        steps.each_with_object([]) do |step, result|
+          args = step.args.map do |arg|
+            arg.is_a?(Steps) ? ShortcutsApplyer.call(arg) : arg
+          end
+
+          if shortcuts.include?(step.name)
+            t = TraversalStart.new(shortcuts)
+            action = shortcuts[step.name].apply(t, *args, **step.params)
+            next if action.nil? || action == t # Shortcut did not add any steps
+
+            new_steps = ShortcutsApplyer.call(Steps.from(action))
+            result.concat(new_steps.configuration_steps)
+            result.concat(new_steps.steps)
+          else
+            result << StepData.new(step.name, args: args, params: step.params)
+          end
         end
       end
     end

data/lib/grumlin/steps_serializers/bytecode.rb

@@ -22,7 +22,12 @@ module Grumlin
       private
 
       def serialize_step(step)
-        [step.name, *step.args.map { |arg| serialize_arg(arg) }, step.params.any? ? step.params : nil].compact
+        [step.name].tap do |result|
+          step.args.each do |arg|
+            result << serialize_arg(arg)
+          end
+          result << step.params if step.params.any?
+        end
       end
 
       def serialize_arg(arg)

data/lib/grumlin/traversal_start.rb

@@ -31,7 +31,7 @@ module Grumlin
     end
 
     def __
-      TraversalStart.new(@shortcuts) # TODO: allow only regular and start steps
+      @__ ||= TraversalStart.new(@shortcuts) # TODO: allow only regular and start steps
     end
 
     def to_s(*)

data/lib/grumlin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Grumlin
-  VERSION = "0.18.1"
+  VERSION = "0.19.0"
 end

data/lib/grumlin.rb

@@ -17,6 +17,8 @@ require "async/barrier"
 require "async/http/endpoint"
 require "async/websocket/client"
 
+require "retryable"
+
 require "zeitwerk"
 
 loader = Zeitwerk::Loader.for_gem
@@ -80,6 +82,27 @@ module Grumlin
 
   class ServerError < ServerSideError; end
 
+  class AlreadyExistsError < ServerError
+    attr_reader :id
+
+    def initialize(status, query)
+      super
+      id = status[:message].split(":").last.strip
+      @id = id == "" ? nil : id
+    end
+
+    # TODO: parse message and assign @id
+    # NOTE: Neptune does not return id.
+  end
+
+  class VertexAlreadyExistsError < AlreadyExistsError; end
+  class EdgeAlreadyExistsError < AlreadyExistsError; end
+
+  class ConcurrentInsertFailedError < ServerError; end
+
+  class ConcurrentVertexInsertFailedError < ConcurrentInsertFailedError; end
+  class ConcurrentEdgeInsertFailedError < ConcurrentInsertFailedError; end
+
   class ServerSerializationError < ServerSideError; end
 
   class ServerTimeoutError < ServerSideError; end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.18.1
+  version: 0.19.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-04-14 00:00:00.000000000 Z
+date: 2022-05-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-pool
@@ -52,6 +52,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.12'
+- !ruby/object:Gem::Dependency
+  name: retryable
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
 - !ruby/object:Gem::Dependency
   name: zeitwerk
   requirement: !ruby/object:Gem::Requirement
@@ -113,10 +127,13 @@ files:
 - lib/grumlin/path.rb
 - lib/grumlin/property.rb
 - lib/grumlin/repository.rb
+- lib/grumlin/repository/error_handling_strategy.rb
+- lib/grumlin/repository/instance_methods.rb
 - lib/grumlin/request_dispatcher.rb
 - lib/grumlin/shortcut.rb
 - lib/grumlin/shortcuts.rb
 - lib/grumlin/shortcuts/properties.rb
+- lib/grumlin/shortcuts/upserts.rb
 - lib/grumlin/shortcuts_applyer.rb
 - lib/grumlin/step_data.rb
 - lib/grumlin/steps.rb