grumlin 0.17.0 → 0.19.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 2d63d3923f895d20e89fd1647495d99bb3a97888689c8f25c34973355d7c80e1
-  data.tar.gz: 878546a65736522f3c1f00f42741b6b207e992a1983321205d05406e0a74ed6b
+  metadata.gz: f899b66f4f483334c271ca60f6ade26d5b403bc10552e03700595e983e0268cb
+  data.tar.gz: ea689ad161f0b220e37af0fd5aa32adaa50990ebdcdc6d8e8cef7b12b53067e5
 SHA512:
-  metadata.gz: 60bf726b74019b36bb0437c78b97ea1ba78703058ba2a619805e0081d49158f30bb67cc7918b959cf0375c37a5600632a1df805563edccb0266b71c9ab70f1de
-  data.tar.gz: cc7dc9ecfd45c67b28301593d3ba60e471e7a9993460ce39dcb912bbed5fb0aa01ed25bcf52f49634f704d6732ba563d849fb8d492276f19fe83e5e8531a8181
+  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
@@ -44,6 +45,7 @@ Naming/MethodParameterName:
     - outV
     - inVLabel
     - outVLabel
+    - to
 
 RSpec/NamedSubject:
   Enabled: false

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.17.0)
+    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

@@ -77,8 +77,7 @@ end
 
 **Shortcuts** is a way to share and organize gremlin code. They let developers define their own steps consisting of
 sequences of standard gremlin steps, other shortcuts and even add new initially unsupported by Grumlin steps.
-Remember ActiveRecord scopes? Shortcuts are very similar. `Grumlin::Shortcuts#with_shortcuts` wraps a given object into
-a proxy object that simply proxies all methods existing in the wrapped object to it and handles shortcuts.
+Remember ActiveRecord scopes? Shortcuts are very similar.
 
 **Important**: if a shortcut's name matches a name of a method defined on the wrapped object, this shortcut will be
 be ignored because methods have higher priority. You cannot override supported by Grumlin steps with shortcuts, 
@@ -128,17 +127,18 @@ class MyRepository
 
   # Wrapping a traversal
   def red_triangles
-    with_shortcuts(g).V.hasLabel(:triangle)
-                       .hasColor("red")
-                       .toList
+    g(self.class.shortcuts).V.hasLabel(:triangle)
+       .hasColor("red")
+       .toList
   end
 
   # Wrapping _
   def something_else
-    with_shortcuts(g).V.hasColor("red")
-                       .repeat(with_shortcuts(__)
-                       .out(:has)
-                       .hasColor("blue")).toList
+    g(self.class.shortcuts).V.hasColor("red")
+       .repeat(__(self.class.shortcuts))
+       .out(:has)
+       .hasColor("blue")
+       .toList
   end
 end
 ```
@@ -183,6 +183,22 @@ Each `return_mode` is mapped to a particular termination step:
 - `:none` - `iterate`
 - `:traversal` - do not execute the query and return the traversal as is
 
+`Grumlin::Repository` also provides a set of generic CRUD operations:
+- `add_vertex(label, id = nil, **properties)`
+- `add_edge(label, id = nil, from:, to:, **properties)`
+- `drop_vertex(id)`
+- `drop_edge(id = nil, from: nil, to: nil, label: nil)`
+
+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**
 
 To execute the query defined in a query block one simply needs to call a method with the same name:

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/action.rb

@@ -49,12 +49,6 @@ module Grumlin
       @shortcuts.key?(@name)
     end
 
-    def arguments
-      @arguments ||= [*@args].tap do |args|
-        args << @params if @params.any?
-      end
-    end
-
     def method_missing(name, *args, **params)
       return step(name, *args, **params) if @shortcuts.key?(name)
 

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,22 +9,12 @@ module Grumlin
       traversal: :nil
     }.freeze
 
-    module InstanceMethods
-      def __
-        TraversalStart.new(self.class.shortcuts)
-      end
-
-      def g
-        TraversalStart.new(self.class.shortcuts)
-      end
-    end
-
     def self.extended(base)
       base.extend(Grumlin::Shortcuts)
-      base.include(Grumlin::Expressions)
-      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

@@ -5,17 +5,15 @@ module Grumlin
     module Properties
       extend Grumlin::Shortcuts
 
-      shortcut :props do |props|
-        next if props.nil? # TODO: fixme, add proper support for **params
+      shortcut :props do |**props|
+        props.reduce(self) do |tt, (prop, value)| # rubocop:disable Style/EachWithObject
+          next tt.property(prop, value) unless value.nil? # nils are not supported
 
-        props.reduce(self) do |tt, (prop, value)|
-          tt.property(prop, value)
+          tt
         end
       end
 
-      shortcut :hasAll do |props|
-        next if props.nil? # TODO: fixme, add proper support for **params
-
+      shortcut :hasAll do |**props|
         props.reduce(self) do |tt, (prop, value)|
           tt.has(prop, value)
         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, step.arguments)
+        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|
-        arguments = step.arguments.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, *arguments)
-          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, arguments)
+      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/step_data.rb

@@ -2,17 +2,19 @@
 
 module Grumlin
   class StepData
-    attr_reader :name, :arguments
+    attr_reader :name, :args, :params
 
-    def initialize(name, arguments)
+    def initialize(name, args: [], params: {})
       @name = name
-      @arguments = arguments
+      @args = args
+      @params = params
     end
 
     def ==(other)
       self.class == other.class &&
         @name == other.name &&
-        @arguments == other.arguments
+        @args == other.args &&
+        @params == other.params
     end
   end
 end

data/lib/grumlin/steps.rb

@@ -18,7 +18,7 @@ module Grumlin
 
       new(shortcuts).tap do |chain|
         actions.each do |act|
-          chain.add(act.name, act.arguments)
+          chain.add(act.name, args: act.args, params: act.params)
         end
       end
     end
@@ -31,10 +31,10 @@ module Grumlin
       @steps = steps
     end
 
-    def add(name, arguments)
-      return add_configuration_step(name, arguments) if CONFIGURATION_STEPS.include?(name)
+    def add(name, args: [], params: {})
+      return add_configuration_step(name, args: args, params: params) if CONFIGURATION_STEPS.include?(name)
 
-      StepData.new(name, cast_arguments(arguments)).tap do |step|
+      StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
         @steps << step
       end
     end
@@ -56,16 +56,16 @@ module Grumlin
 
     def shortcuts?(steps_ary)
       steps_ary.any? do |step|
-        @shortcuts.include?(step.name) || step.arguments.any? do |arg|
+        @shortcuts.include?(step.name) || step.args.any? do |arg|
           arg.is_a?(Steps) ? arg.uses_shortcuts? : false
         end
       end
     end
 
-    def add_configuration_step(name, arguments)
+    def add_configuration_step(name, args: [], params: {})
       raise ArgumentError, "cannot use configuration steps after start step was used" unless @steps.empty?
 
-      StepData.new(name, cast_arguments(arguments)).tap do |step|
+      StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
         @configuration_steps << step
       end
     end

data/lib/grumlin/steps_serializers/bytecode.rb

@@ -6,7 +6,7 @@ module Grumlin
       # constructor params: no_return: true|false, default false
       # TODO: add pretty
 
-      NONE_STEP = StepData.new("none", [])
+      NONE_STEP = StepData.new("none")
 
       def serialize
         steps = ShortcutsApplyer.call(@steps)
@@ -22,7 +22,12 @@ module Grumlin
       private
 
       def serialize_step(step)
-        [step.name, *step.arguments.map { |arg| serialize_arg(arg) }]
+        [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/steps_serializers/human_readable_bytecode.rb

@@ -2,22 +2,16 @@
 
 module Grumlin
   module StepsSerializers
-    class HumanReadableBytecode < Serializer
+    class HumanReadableBytecode < Bytecode
       def serialize
         steps = ShortcutsApplyer.call(@steps)
-        [serialize_steps(steps.configuration_steps), serialize_steps(steps.steps)]
-      end
-
-      def serialize_steps(steps)
-        steps.map { |s| serialize_step(s) }
+        [steps.configuration_steps, steps.steps].map do |stps|
+          stps.map { |s| serialize_step(s) }
+        end
       end
 
       private
 
-      def serialize_step(step)
-        [step.name, *step.arguments.map { |arg| serialize_arg(arg) }]
-      end
-
       def serialize_arg(arg)
         return arg.to_s if arg.is_a?(TypedValue)
         return serialize_predicate(arg) if arg.is_a?(Expressions::P::Predicate)

data/lib/grumlin/steps_serializers/string.rb

@@ -10,14 +10,21 @@ module Grumlin
       def serialize
         steps = @params[:apply_shortcuts] ? ShortcutsApplyer.call(@steps) : @steps
 
-        configuration_steps = serialize_steps(steps.configuration_steps)
-        regular_steps = serialize_steps(steps.steps)
+        steps = [steps.configuration_steps, steps.steps].map do |stps|
+          stps.map { |step| serialize_step(step) }
+        end
 
-        "#{prefix}.#{(configuration_steps + regular_steps).join(".")}"
+        "#{prefix}.#{(steps[0] + steps[1]).join(".")}"
       end
 
       private
 
+      def serialize_step(step)
+        "#{step.name}(#{(step.args + [step.params.any? ? step.params : nil].compact).map do |a|
+          serialize_arg(a)
+        end.join(", ")})"
+      end
+
       def prefix
         @prefix ||= @params[:anonymous] ? "__" : "g"
       end
@@ -31,12 +38,6 @@ module Grumlin
 
         StepsSerializers::String.new(arg, anonymous: true, **@params).serialize
       end
-
-      def serialize_steps(steps)
-        steps.map do |step|
-          "#{step.name}(#{step.arguments.map { |a| serialize_arg(a) }.join(", ")})"
-        end
-      end
     end
   end
 end

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/typing.rb

@@ -18,7 +18,7 @@ module Grumlin
       # "g:VertexProperty"=> ->(value) { value }, # TODO: implement me
       "g:TraversalMetrics" => ->(value) { cast_map(value[:@value]) },
       "g:Metrics" => ->(value) { cast_map(value[:@value]) },
-      "g:T" => ->(value) { value.to_sym }
+      "g:T" => ->(value) { Grumlin::Expressions::T.public_send(value) }
     }.freeze
 
     CASTABLE_TYPES = [Hash, String, Integer, TrueClass, FalseClass].freeze

data/lib/grumlin/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Grumlin
-  VERSION = "0.17.0"
+  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.17.0
+  version: 0.19.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-03-30 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
@@ -155,7 +172,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.2.33
 signing_key: 
 specification_version: 4
 summary: Gremlin graph traversal language DSL and client for Ruby.