grumlin 0.22.5 → 0.23.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 88898067f66c807c685077f768ca71db95d7b246540764334b421f0c86fe92cc
-  data.tar.gz: 5801ac047063d58395e36e194f961ccb2abce3eb772a0b7648c3f35434700c53
+  metadata.gz: 0560f7bf90bba9601628d6042ac1286076f9a8e9039b6f8e755b6f4beedb3e1a
+  data.tar.gz: 83b7b4409198a6cbb5520b003e2dcdacfe8623b9aa8c057b0e9df1e29692a4f3
 SHA512:
-  metadata.gz: b6377eb1c36a2caf2536f92574d17a57e7da76f8f8cb7995280aabcde1412fc84e214cdb8a296a3d61d6736efd073e09c415b7a34bdf686567b427eb434ca21e
-  data.tar.gz: 172be358c5882da351e2d12db7688a2521808becf0a027c870fa38b27836e76b82b7a995ddf880f4cc205639dba92dfdc771908450891ac6117f241617969c6a
+  metadata.gz: f87b6a69c71ebd867f227b35e13a50c499d054c6688747465e05a41426167ee3ffea5afbfb1875ca5c49e6a0c2a97f42ea20b93f9cf32cd5966942ba844f839c
+  data.tar.gz: 4b5262eacf5e57f4ad95e6cc5f450d924858b1e238e2bf3943b9b127da53db36c76078b22d8ba5d244aa35e5d0ddfc4db45516481bd41c58bbe2123ac262dd5f

data/.gitignore

@@ -2,7 +2,6 @@
 /.yardoc
 /_yardoc/
 /coverage/
-/doc/
 /pkg/
 /spec/reports/
 /tmp/

data/Gemfile.lock

@@ -1,9 +1,10 @@
 PATH
   remote: .
   specs:
-    grumlin (0.22.5)
+    grumlin (0.23.0)
       async-pool (~> 0.3)
       async-websocket (>= 0.19, < 0.20)
+      ibsciss-middleware (~> 0.4.0)
       oj (~> 3.13)
       retryable (~> 3.0)
       zeitwerk (~> 2.6)
@@ -21,7 +22,7 @@ GEM
       console (~> 1.10)
       nio4r (~> 2.3)
       timers (~> 4.1)
-    async-http (0.59.1)
+    async-http (0.59.2)
       async (>= 1.25)
       async-io (>= 1.28)
       async-pool (>= 0.2)
@@ -29,9 +30,9 @@ GEM
       protocol-http1 (~> 0.14.0)
       protocol-http2 (~> 0.14.0)
       traces (>= 0.4.0)
-    async-io (1.33.0)
+    async-io (1.34.0)
       async
-    async-pool (0.3.11)
+    async-pool (0.3.12)
       async (>= 1.25)
     async-rspec (1.16.1)
       rspec (~> 3.0)
@@ -57,6 +58,7 @@ GEM
     fiber-local (1.0.0)
     i18n (1.12.0)
       concurrent-ruby (~> 1.0)
+    ibsciss-middleware (0.4.2)
     iniparse (1.5.0)
     jaro_winkler (1.5.4)
     json (2.6.2)
@@ -78,8 +80,8 @@ GEM
     parser (3.1.2.1)
       ast (~> 2.4.1)
     protocol-hpack (1.4.2)
-    protocol-http (0.23.5)
-    protocol-http1 (0.14.4)
+    protocol-http (0.23.12)
+    protocol-http1 (0.14.6)
       protocol-http (~> 0.22)
     protocol-http2 (0.14.2)
       protocol-hpack (~> 1.4)
@@ -154,8 +156,8 @@ GEM
       yard (~> 0.9, >= 0.9.24)
     thor (1.2.1)
     tilt (2.0.11)
-    timers (4.3.3)
-    traces (0.6.1)
+    timers (4.3.4)
+    traces (0.7.0)
     tzinfo (2.0.5)
       concurrent-ruby (~> 1.0)
     unicode-display_width (2.2.0)

data/README.md

@@ -295,6 +295,14 @@ it may be useful for debugging. Note that one needs to call a termination step m
 
 method will return profiling data of the results.
 
+##### Middlewares
+
+Middlewares can be used to perform certain actions before and after every query made by `Grumlin`. It can be useful for
+measuring query execution time or performing some modification or validation to the query before it reaches the server or
+modify the response before client gets it.
+
+See [doc/middlewares.md](doc/middlewares.md) for more info and examples.
+
 #### Transactions
 
 Since 0.22.0 `Grumlin` supports transactions when working with providers that supports them:

data/doc/middlewares.md

@@ -0,0 +1,58 @@
+# Middlewares
+
+Every single query performed by `Grumlin` goes through a stack of middlewares just like every single request in Rails 
+or many other web frameworks. `Grumlin` ships with a set of middlewares, each one performs some part of the query
+execution process:
+
+- `Middlewares::SerializeToSteps` - converts a `Step` into `Steps`
+- `Middlewares::ApplyShortcuts` - applies shortcuts to `Steps`
+- `Middlewares::SerializeToBytecode` - converts `Steps` into bytecode
+- `Middlewares::BuildQuery` - builds an actual message that will be send to server
+- `Middlewares::CastResults` - casts server response into ruby objects
+- `Middlewares::RunQuery` - actually sends the message to the server
+
+Normally these middlewares must never be rearranged or removed from the stack. Middlewares added after
+`Middlewares::RunQuery` will not be executed.
+
+# Writing a middleware for Grumlin
+
+This entire feature is built on top of [ibsciss-middleware](https://github.com/Ibsciss/ruby-middleware).
+Please refer to it's docs if you want to implement a middleware.
+
+
+A minimal middleware that measures query execution time and puts it back to `env`:
+
+```ruby
+class MeasureExecutionTime < Grumlin::Middlewares::Middleware # Middleware provides only an initializer with one argument for `app`
+  def call(env)
+    started = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    result = @app.call(env)
+    env[:execution_time] = Process.clock_gettime(Process::CLOCK_MONOTONIC) - started
+    result
+  end
+end
+
+Grumlin.configure do |cfg|
+  cfg.url = ENV.fetch("GREMLIN_URL", "ws://localhost:8182/gremlin")
+  cfg.provider = :tinkergraph
+
+  cfg.middlewares.insert_before Grumlin::Middlewares::CastResults, MeasureExecutionTime
+end
+```
+
+When placed right before `Grumlin::Middlewares::CastResults` your middleware will have access to every intermediate result
+of the query execution process:
+- `env[:traversal]` - contains the original traversal
+- `env[:steps]` - contains the `Steps` representing the traversal
+- `env[:steps_without_shortcuts]` - contains the `Steps` representing the traversal, but with all shortcuts applied
+- `env[:bytecode]` - raw bytecode of the traversal
+- `env[:query]` - raw message that will be sent to the server. `requestId` can be found here: `env[:query][:requestId]`
+
+After the query is performed (after `@app.call(env)`), these keys become available:
+- `env[:results]` - raw results received from the server
+- `env[:parsed_results]` - server results mapped to ruby types, basically the query results as the client gets it
+
+Other useful parts of `env`:
+- `env[:session_id]` - id of the session when executed inside a transaction, otherwise `nil`
+- `env[:pool]` - connection pool that will be used to interact with the server
+- `env[:need_results]` - flag stating whether the client needs the query execution results(`toList`, `next`) or not(`iterate`)

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", "< 0.20"
+  spec.add_dependency "ibsciss-middleware", "~> 0.4.0"
   spec.add_dependency "oj", "~> 3.13"
   spec.add_dependency "retryable", "~> 3.0"
   spec.add_dependency "zeitwerk", "~> 2.6"

data/lib/grumlin/client.rb

@@ -24,8 +24,8 @@ module Grumlin
         @client.close
       end
 
-      def write(bytecode, session_id: nil)
-        @client.write(bytecode, session_id: session_id)
+      def write(query)
+        @client.write(query)
       ensure
         @count += 1
       end
@@ -94,15 +94,13 @@ module Grumlin
     end
 
     # TODO: support yielding
-    def write(bytecode, session_id: nil)
+    def write(query)
       raise NotConnectedError unless connected?
 
-      request = to_query(bytecode, session_id: session_id)
-
-      channel = @request_dispatcher.add_request(request)
+      channel = @request_dispatcher.add_request(query)
       begin
-        @transport.write(request)
-        channel.dequeue.flat_map { |item| Typing.cast(item) }
+        @transport.write(query)
+        channel.dequeue
       rescue Async::Stop, Async::TimeoutError
         close(check_requests: false)
         raise
@@ -123,21 +121,5 @@ module Grumlin
     def build_transport
       Transport.new(@url, parent: @parent, **@client_options)
     end
-
-    def to_query(bytecode, session_id:)
-      {
-        requestId: SecureRandom.uuid,
-        op: :bytecode,
-        processor: session_id ? :session : :traversal,
-        args: {
-          gremlin: {
-            :@type => "g:Bytecode",
-            :@value => bytecode.serialize
-          },
-          aliases: { g: :g },
-          session: session_id
-        }.compact
-      }
-    end
   end
 end

data/lib/grumlin/config.rb

@@ -6,6 +6,15 @@ module Grumlin
 
     SUPPORTED_PROVIDERS = %i[neptune tinkergraph].freeze
 
+    DEFAULT_MIDDLEWARES = Middleware::Builder.new do |b|
+      b.use Middlewares::SerializeToSteps
+      b.use Middlewares::ApplyShortcuts
+      b.use Middlewares::SerializeToBytecode
+      b.use Middlewares::BuildQuery
+      b.use Middlewares::CastResults
+      b.use Middlewares::RunQuery
+    end.freeze
+
     class ConfigurationError < Grumlin::Error; end
 
     class UnknownProviderError < ConfigurationError; end
@@ -17,6 +26,12 @@ module Grumlin
       @client_factory = ->(url, parent) { Grumlin::Client.new(url, parent: parent) }
     end
 
+    def middlewares
+      @middlewares ||= Middleware::Builder.new do |b|
+        b.use DEFAULT_MIDDLEWARES
+      end
+    end
+
     def validate!
       return if SUPPORTED_PROVIDERS.include?(provider.to_sym)
 

data/lib/grumlin/dummy_transaction.rb

@@ -6,7 +6,7 @@ module Grumlin
 
     include Console
 
-    def initialize(traversal_start_class, pool: nil) # rubocop:disable Lint/MissingSuper, Lint/UnusedMethodArgument
+    def initialize(traversal_start_class, middlewares:, pool: nil) # rubocop:disable Lint/MissingSuper, Lint/UnusedMethodArgument
       @traversal_start_class = traversal_start_class
 
       logger.info(self) do

data/lib/grumlin/middlewares/apply_shortcuts.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Middlewares
+    class ApplyShortcuts < Middleware
+      def call(env)
+        env[:steps_without_shortcuts] = ShortcutsApplyer.call(env[:steps])
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/grumlin/middlewares/build_query.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Middlewares
+    class BuildQuery < Middleware
+      def call(env)
+        env[:query] = {
+          requestId: SecureRandom.uuid,
+          op: :bytecode,
+          processor: env[:session_id] ? :session : :traversal,
+          args: {
+            gremlin: {
+              :@type => "g:Bytecode",
+              :@value => env[:bytecode]
+            },
+            aliases: { g: :g },
+            session: env[:session_id]
+          }.compact
+        }
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/grumlin/middlewares/cast_results.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Middlewares
+    class CastResults < Middleware
+      def call(env)
+        env[:parsed_results] = @app.call(env).flat_map { |item| Typing.cast(item) }
+      end
+    end
+  end
+end

data/lib/grumlin/middlewares/frozen_builder.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Middlewares
+    class FrozenBuilder < ::Middleware::Builder
+      def initialize(opts = nil, &block)
+        super(opts, &block)
+        freeze
+      end
+
+      def freeze
+        super
+
+        stack.freeze
+      end
+    end
+  end
+end

data/lib/grumlin/middlewares/middleware.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Middlewares
+    class Middleware
+      def initialize(app)
+        @app = app
+      end
+
+      def call(env)
+        raise NotImplementedError
+      end
+    end
+  end
+end

data/lib/grumlin/middlewares/run_query.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Middlewares
+    class RunQuery < Middleware
+      def call(env)
+        env[:results] = env[:pool].acquire { |c| c.write(env[:query]) }
+      end
+    end
+  end
+end

data/lib/grumlin/middlewares/serialize_to_bytecode.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Middlewares
+    class SerializeToBytecode < Middleware
+      def call(env)
+        env[:bytecode] = StepsSerializers::Bytecode.new(env[:steps_without_shortcuts],
+                                                        no_return: !env[:need_results]).serialize
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/grumlin/middlewares/serialize_to_steps.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Grumlin
+  module Middlewares
+    class SerializeToSteps < Middleware
+      def call(env)
+        env[:steps] = Steps.from(env[:traversal])
+        @app.call(env)
+      end
+    end
+  end
+end

data/lib/grumlin/repository.rb

@@ -32,9 +32,9 @@ module Grumlin
         t = instance_exec(*args, **params, &query_block)
         return t if t.nil? || (t.respond_to?(:empty?) && t.empty?)
 
-        unless t.is_a?(Grumlin::Action)
+        unless t.is_a?(Grumlin::Step)
           raise WrongQueryResult,
-                "queries must return #{Grumlin::Action}, nil or an empty collection. Given: #{t.class}"
+                "queries must return #{Grumlin::Step}, nil or an empty collection. Given: #{t.class}"
         end
 
         return block.call(t) unless block.nil?

data/lib/grumlin/shortcuts/storage.rb

@@ -33,10 +33,10 @@ module Grumlin
       def add(name, shortcut)
         @storage[name] = shortcut
 
-        ac = action_class
+        sc = step_class
 
         shortcut_methods_module.define_method(name) do |*args, **params|
-          next ac.new(name, args: args, params: params, previous_step: self, pool: Grumlin.default_pool)
+          next sc.new(name, args: args, params: params, previous_step: self, pool: Grumlin.default_pool)
         end
         extend_traversal_classes(shortcut) unless shortcut.lazy?
       end
@@ -59,8 +59,8 @@ module Grumlin
         @traversal_start_class ||= shortcut_aware_class(TraversalStart)
       end
 
-      def action_class
-        @action_class ||= shortcut_aware_class(Action)
+      def step_class
+        @step_class ||= shortcut_aware_class(Step)
       end
 
       protected
@@ -91,7 +91,7 @@ module Grumlin
         m = Module.new do
           define_method(shortcut.name, &shortcut.block)
         end
-        action_class.include(m)
+        step_class.include(m)
         traversal_start_class.include(m)
       end
     end

data/lib/grumlin/shortcuts.rb

@@ -15,7 +15,7 @@ module Grumlin
       name = name.to_sym
       lazy = false if override
 
-      if Grumlin::Action::REGULAR_STEPS.include?(name) && !override
+      if Grumlin::Step::REGULAR_STEPS.include?(name) && !override
         raise ArgumentError,
               "overriding standard gremlin steps is not allowed, if you know what you're doing, pass `override: true`"
       end

data/lib/grumlin/shortcuts_applyer.rb

@@ -30,10 +30,10 @@ module Grumlin
           next result << StepData.new(step.name, args: args, params: step.params) unless shortcut&.lazy?
 
           t = shortcuts.__
-          action = shortcut.apply(t, *args, **step.params)
-          next if action.nil? || action == t # Shortcut did not add any steps
+          step = shortcut.apply(t, *args, **step.params)
+          next if step.nil? || step == t # Shortcut did not add any steps
 
-          new_steps = call(Steps.from(action))
+          new_steps = call(Steps.from(step))
           result.concat(new_steps.configuration_steps, new_steps.steps)
         end
       end

data/lib/grumlin/{action.rb → step.rb}

@@ -1,15 +1,16 @@
 # frozen_string_literal: true
 
 module Grumlin
-  class Action < Steppable
+  class Step < Steppable
     attr_reader :name, :args, :params, :next_step, :configuration_steps, :previous_step, :shortcut
 
-    # client is only used when a traversal is a part of transaction
-    def initialize(name, args: [], params: {}, previous_step: nil, pool: nil, session_id: nil)
-      super(pool: pool, session_id: session_id)
+    # TODO: replace pool, session_id and middlewares with a context?
+    def initialize(name, args: [], params: {}, previous_step: nil, pool: nil, session_id: nil, # rubocop:disable Metrics/ParameterLists
+                   middlewares: Grumlin.default_middlewares)
+      super(pool: pool, session_id: session_id, middlewares: middlewares)
 
       @name = name.to_sym
-      @args = args # TODO: add recursive validation: only json types or Action
+      @args = args # TODO: add recursive validation: only json types or Step
       @params = params # TODO: add recursive validation: only json types
       @previous_step = previous_step
       @shortcut = shortcuts[@name]
@@ -74,19 +75,20 @@ module Grumlin
     end
 
     def toList
-      client_write(bytecode)
+      send_query(need_results: true)
     end
 
     def iterate
-      client_write(bytecode(no_return: true))
+      send_query(need_results: false)
     end
 
     private
 
-    def client_write(payload)
-      @pool.acquire do |client|
-        client.write(payload, session_id: @session_id)
-      end
+    def send_query(need_results:)
+      @middlewares.call(traversal: self,
+                        need_results: need_results,
+                        session_id: @session_id,
+                        pool: @pool)
     end
   end
 end

data/lib/grumlin/steppable.rb

@@ -12,10 +12,12 @@ module Grumlin
 
     ALL_STEPS = START_STEPS + CONFIGURATION_STEPS + REGULAR_STEPS
 
-    def initialize(pool: nil, session_id: nil)
+    def initialize(pool: nil, session_id: nil, middlewares: Grumlin.default_middlewares)
       @pool = pool
       @session_id = session_id
 
+      @middlewares = middlewares
+
       return if respond_to?(:shortcuts)
 
       raise "steppable must not be initialized directly, use Grumlin::Shortcuts::Storage#g or #__ instead"
@@ -23,14 +25,14 @@ module Grumlin
 
     ALL_STEPS.each do |step|
       define_method step do |*args, **params|
-        shortcuts.action_class.new(step, args: args, params: params, previous_step: self,
-                                         session_id: @session_id, pool: @pool)
+        shortcuts.step_class.new(step, args: args, params: params, previous_step: self,
+                                       session_id: @session_id, pool: @pool, middlewares: @middlewares)
       end
     end
 
     def step(name, *args, **params)
-      shortcuts.action_class.new(name, args: args, params: params, previous_step: self,
-                                       session_id: @session_id, pool: @pool)
+      shortcuts.step_class.new(name, args: args, params: params, previous_step: self,
+                                     session_id: @session_id, pool: @pool, middlewares: @middlewares)
     end
 
     def_delegator :shortcuts, :__

data/lib/grumlin/steps.rb

@@ -2,23 +2,16 @@
 
 module Grumlin
   class Steps
-    CONFIGURATION_STEPS = Action::CONFIGURATION_STEPS
-    ALL_STEPS = Action::ALL_STEPS
+    CONFIGURATION_STEPS = Step::CONFIGURATION_STEPS
+    ALL_STEPS = Step::ALL_STEPS
 
-    def self.from(action)
-      raise ArgumentError, "expected: #{Action}, given: #{action.class}" unless action.is_a?(Action)
+    def self.from(step)
+      raise ArgumentError, "expected: #{Step}, given: #{step.class}" unless step.is_a?(Step)
 
-      shortcuts = action.shortcuts
-      actions = []
-
-      until action.nil? || action.is_a?(TraversalStart)
-        actions.unshift(action)
-        action = action.previous_step
-      end
-
-      new(shortcuts).tap do |chain|
-        actions.each do |act|
-          chain.add(act.name, args: act.args, params: act.params)
+      new(step.shortcuts).tap do |chain|
+        until step.nil? || step.is_a?(TraversalStart)
+          chain.add(step.name, args: step.args, params: step.params, to: :begin)
+          step = step.previous_step
         end
       end
     end
@@ -31,13 +24,16 @@ module Grumlin
       @steps = steps
     end
 
-    def add(name, args: [], params: {})
+    def add(name, args: [], params: {}, to: :end)
       if CONFIGURATION_STEPS.include?(name) || name.to_sym == :tx
-        return add_configuration_step(name, args: args, params: params)
+        return add_configuration_step(name, args: args, params: params, to: to)
       end
 
       StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
-        @steps << step
+        next @steps << step if to == :end
+        next @steps.unshift(step) if to == :begin
+
+        raise ArgumentError, "'to:' must be either :begin or :end, given: '#{to}'"
       end
     end
 
@@ -64,16 +60,19 @@ module Grumlin
       end
     end
 
-    def add_configuration_step(name, args: [], params: {})
-      raise ArgumentError, "cannot use configuration steps after start step was used" unless @steps.empty?
+    def add_configuration_step(name, args: [], params: {}, to: :end)
+      raise ArgumentError, "cannot use configuration steps after start step was used" if @steps.any? && to == :end
 
       StepData.new(name, args: cast_arguments(args), params: params).tap do |step|
-        @configuration_steps << step
+        next @configuration_steps << step if to == :end
+        next @configuration_steps.unshift(step) if to == :begin
+
+        raise ArgumentError, "to must be either :begin or :end, given: '#{to}'"
       end
     end
 
     def cast_arguments(arguments)
-      arguments.map { |arg| arg.is_a?(Action) ? Steps.from(arg) : arg }
+      arguments.map { |arg| arg.is_a?(Step) ? Steps.from(arg) : arg }
     end
   end
 end

data/lib/grumlin/transaction.rb

@@ -6,14 +6,14 @@ module Grumlin
 
     include Console
 
-    COMMIT = Grumlin::Repository.new.g.step(:tx, :commit).bytecode
-    ROLLBACK = Grumlin::Repository.new.g.step(:tx, :rollback).bytecode
+    COMMIT = Grumlin::Repository.new.g.step(:tx, :commit)
+    ROLLBACK = Grumlin::Repository.new.g.step(:tx, :rollback)
 
-    def initialize(traversal_start_class, pool:)
+    def initialize(traversal_start_class, pool:, middlewares:)
       @traversal_start_class = traversal_start_class
       @pool = pool
-
       @session_id = SecureRandom.uuid
+      @middlewares = middlewares
     end
 
     def begin
@@ -30,10 +30,11 @@ module Grumlin
 
     private
 
-    def finalize(action)
-      @pool.acquire do |client|
-        client.write(action, session_id: @session_id)
-      end
+    def finalize(step)
+      @middlewares.call(traversal: step,
+                        need_results: false,
+                        session_id: @session_id,
+                        pool: @pool)
     end
   end
 end

data/lib/grumlin/traversal_start.rb

@@ -10,7 +10,7 @@ module Grumlin
     def tx
       raise AlreadyBoundToTransactionError if @session_id
 
-      transaction = tx_class.new(self.class, pool: @pool)
+      transaction = tx_class.new(self.class, pool: @pool, middlewares: @middlewares)
       return transaction unless block_given?
 
       begin

data/lib/grumlin/version.rb

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

data/lib/grumlin/with_extension.rb

@@ -4,22 +4,22 @@ module Grumlin
   module WithExtension
     def with(name, value)
       prev = self
-      strategy = if is_a?(with_action_class)
+      strategy = if is_a?(with_step_class)
                    prev = previous_step
                    TraversalStrategies::OptionsStrategy.new(args.first.value.merge(name => value))
                  else
                    TraversalStrategies::OptionsStrategy.new({ name => value })
                  end
-      with_action_class.new(:withStrategies, args: [strategy], previous_step: prev)
+      with_step_class.new(:withStrategies, args: [strategy], previous_step: prev)
     end
 
     private
 
-    def with_action_class
-      @with_action_class ||= Class.new(shortcuts.action_class) do
+    def with_step_class
+      @with_step_class ||= Class.new(shortcuts.step_class) do
         include WithExtension
 
-        def with_action_class
+        def with_step_class
           self.class
         end
       end

data/lib/grumlin.rb

@@ -17,6 +17,7 @@ require "async/barrier"
 require "async/http/endpoint"
 require "async/websocket/client"
 
+require "middleware"
 require "retryable"
 
 require "zeitwerk"
@@ -34,6 +35,7 @@ module Grumlin
   class Error < StandardError; end
 
   class TransactionError < Error; end
+
   class Rollback < TransactionError; end
 
   class UnknownError < Error; end
@@ -99,15 +101,19 @@ module Grumlin
   end
 
   class VertexAlreadyExistsError < AlreadyExistsError; end
+
   class EdgeAlreadyExistsError < AlreadyExistsError; end
 
   class ConcurrentModificationError < ServerError; end
+
   class ConcurrentInsertFailedError < ConcurrentModificationError; end
 
   class ConcurrentVertexInsertFailedError < ConcurrentInsertFailedError; end
+
   class ConcurrentEdgeInsertFailedError < ConcurrentInsertFailedError; end
 
   class ConcurrentVertexPropertyInsertFailedError < ConcurrentInsertFailedError; end
+
   class ConcurrentEdgePropertyInsertFailedError < ConcurrentInsertFailedError; end
 
   class ServerSerializationError < ServerSideError; end
@@ -134,8 +140,6 @@ module Grumlin
 
   class WrongQueryResult < RepositoryError; end
 
-  @pool_mutex = Mutex.new
-
   class << self
     def configure
       yield config
@@ -147,6 +151,10 @@ module Grumlin
       @config ||= Config.new
     end
 
+    def default_middlewares
+      config.middlewares
+    end
+
     # returns a subset of features for currently configured backend.
     # The features lists are hardcoded as there is no way to get them
     # from the remote server.
@@ -155,26 +163,22 @@ module Grumlin
     end
 
     def default_pool
-      if Thread.current.thread_variable_get(:grumlin_default_pool)
-        return Thread.current.thread_variable_get(:grumlin_default_pool)
-      end
-
-      @pool_mutex.synchronize do
-        Thread.current.thread_variable_set(:grumlin_default_pool,
-                                           Async::Pool::Controller.new(Grumlin::Client::PoolResource,
-                                                                       limit: config.pool_size))
-      end
+      t = Thread.current
+      return t.thread_variable_get(:grumlin_default_pool) if t.thread_variable_get(:grumlin_default_pool)
+
+      t.thread_variable_set(:grumlin_default_pool,
+                            Async::Pool::Controller.new(Grumlin::Client::PoolResource,
+                                                        limit: config.pool_size))
     end
 
     def close
-      return if Thread.current.thread_variable_get(:grumlin_default_pool).nil?
-
-      @pool_mutex.synchronize do
-        pool = Thread.current.thread_variable_get(:grumlin_default_pool)
-        pool.wait while pool.busy?
-        pool.close
-        Thread.current.thread_variable_set(:grumlin_default_pool, nil)
-      end
+      t = Thread.current
+      return if t.thread_variable_get(:grumlin_default_pool).nil?
+
+      pool = t.thread_variable_get(:grumlin_default_pool)
+      pool.wait while pool.busy?
+      pool.close
+      t.thread_variable_set(:grumlin_default_pool, nil)
     end
 
     def definitions

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: grumlin
 version: !ruby/object:Gem::Version
-  version: 0.22.5
+  version: 0.23.0
 platform: ruby
 authors:
 - Gleb Sinyavskiy
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2022-08-25 00:00:00.000000000 Z
+date: 2022-09-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: async-pool
@@ -44,6 +44,20 @@ dependencies:
     - - "<"
       - !ruby/object:Gem::Version
         version: '0.20'
+- !ruby/object:Gem::Dependency
+  name: ibsciss-middleware
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.4.0
 - !ruby/object:Gem::Dependency
   name: oj
   requirement: !ruby/object:Gem::Requirement
@@ -110,6 +124,7 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- doc/middlewares.md
 - docker-compose.yml
 - gremlin_server/Dockerfile
 - gremlin_server/tinkergraph-empty.properties
@@ -119,7 +134,6 @@ files:
 - lib/async/channel.rb
 - lib/definitions.yml
 - lib/grumlin.rb
-- lib/grumlin/action.rb
 - lib/grumlin/benchmark/repository.rb
 - lib/grumlin/client.rb
 - lib/grumlin/config.rb
@@ -140,6 +154,14 @@ files:
 - lib/grumlin/features/feature_list.rb
 - lib/grumlin/features/neptune_features.rb
 - lib/grumlin/features/tinkergraph_features.rb
+- lib/grumlin/middlewares/apply_shortcuts.rb
+- lib/grumlin/middlewares/build_query.rb
+- lib/grumlin/middlewares/cast_results.rb
+- lib/grumlin/middlewares/frozen_builder.rb
+- lib/grumlin/middlewares/middleware.rb
+- lib/grumlin/middlewares/run_query.rb
+- lib/grumlin/middlewares/serialize_to_bytecode.rb
+- lib/grumlin/middlewares/serialize_to_steps.rb
 - lib/grumlin/path.rb
 - lib/grumlin/property.rb
 - lib/grumlin/repository.rb
@@ -153,6 +175,7 @@ files:
 - lib/grumlin/shortcuts/storage.rb
 - lib/grumlin/shortcuts/upserts.rb
 - lib/grumlin/shortcuts_applyer.rb
+- lib/grumlin/step.rb
 - lib/grumlin/step_data.rb
 - lib/grumlin/steppable.rb
 - lib/grumlin/steps.rb