treaty 0.11.0 → 0.12.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ec3d8b8448c1cb6634404040ed78864beb81a317b705a14d6f3684caaaf5952
-  data.tar.gz: a21afccd9a25da7531ff561ed4baae2cc0011ed8c9c5b09b7ceb1370b79ba353
+  metadata.gz: c10e0241b816115758a4383e524fc0f9cfb6738e95f4fddff5a1b32eb114c719
+  data.tar.gz: 4a5bfe17af7e6efb87975770aed1a3a67fb817aeee13cdbd05c88c187407efe0
 SHA512:
-  metadata.gz: 0a8281e2551007b9c6b514b3d8d664d484b27e757733dd6a94d191bfdf8cce1d50a5b4f3bdee8fb8e4cadb51b1b90802697f0cd06a929c8cf39482f6aef6c5c3
-  data.tar.gz: 1855561545ee10307c8094377ed28a132a6a9ac8f9347801f9f1d80e7f6adbb6fddc812b34e2b7960336d8558d84e9d48691aeea525c6357962b66e2a0a56e7e
+  metadata.gz: 12b23780c22b9987d317323e723c81d5be07ff2099e74a6cf90c4eab5bb4d0d74a6f0c8b05f11f7800daf16c02d5dd7c317c2d7df770ad99c1638933e94b6297
+  data.tar.gz: 4074fa86260a0f9e79adeaf6b41a61f70f5e568e7cbd6592b4eb8c19c270c954753db941be3490ce40944d1edc8cf9445caf75ef1de0b18e65e7939ad6ffd191

data/README.md

@@ -13,7 +13,7 @@
 </div>
 
 > [!WARNING]
-> **Development Status**: Treaty is currently under active development in the 0.x version series. Breaking changes may occur between minor versions (0.x) as we refine the API and add new features. The library will stabilize with the 1.0 release. We recommend pinning to specific patch versions in your Gemfile (e.g., `gem "treaty", "~> 0.9.0"`) until the 1.0 release.
+> **Development Status**: Treaty is currently under active development in the 0.x version series. Breaking changes may occur between minor versions (0.x) as we refine the API and add new features. The library will stabilize with the 1.0 release. We recommend pinning to specific patch versions in your Gemfile (e.g., `gem "treaty", "~> 0.12.0"`) until the 1.0 release.
 
 ## 📚 Documentation
 
@@ -36,6 +36,7 @@ Treaty provides a complete solution for building versioned APIs in Ruby on Rails
 - **Entity Classes (DTOs)** - Define reusable data transfer objects for better code organization
 - **Built-in Validation** - Validate incoming requests and outgoing responses automatically
 - **Data Transformation** - Transform data seamlessly between different API versions
+- **Inventory System** - Pass controller-specific data to services efficiently
 - **Deprecation Management** - Mark versions as deprecated with flexible conditions
 - **Internationalization** - Full I18n support for multilingual error messages
 - **Well-documented** - Comprehensive guides and examples for every feature
@@ -64,8 +65,6 @@ Create your first API contract in `app/treaties/posts/create_treaty.rb`:
 module Posts
   class CreateTreaty < ApplicationTreaty
     version 1, default: true do
-      strategy Treaty::Strategy::ADAPTER
-
       request do
         object :post do
           string :title
@@ -102,6 +101,18 @@ class PostsController < ApplicationController
   # 3. Validates service response according to response definition
   # 4. Returns transformed data to client
   treaty :create
+
+  # Optional: Provide additional data from controller to service
+  treaty :index do
+    provide :current_user
+    provide :posts, from: :load_posts
+  end
+
+  private
+
+  def load_posts
+    Post.published.limit(10)
+  end
 end
 ```
 

data/config/locales/en.yml

@@ -91,14 +91,10 @@ en:
       # Version factory
       factory:
         invalid_default_option: "Default option for version must be true, false, or a Proc, got: %{type}"
-        unknown_method: "Unknown method '%{method}' in version definition. Available methods: summary, strategy, deprecated, request, response, delegate_to"
+        unknown_method: "Unknown method '%{method}' in version definition. Available methods: summary, deprecated, request, response, delegate_to"
         default_deprecated_conflict: "Version %{version} cannot be both default and deprecated. A default version must be active and usable. Either remove 'default: true' or remove the 'deprecated' declaration."
         multiple_defaults: "Cannot have multiple versions marked as default. Only one version can be the default. Please review your treaty definition and ensure only one version has 'default: true'."
 
-      # Strategy validation
-      strategy:
-        unknown: "Unknown strategy: %{strategy}"
-
     # ============================================================================
     # Execution: Service and executor invocation
     # ============================================================================
@@ -120,3 +116,23 @@ en:
     # ============================================================================
     controller:
       treaty_class_not_found: "%{class_name}"
+
+    # ============================================================================
+    # Inventory: Controller data provisioning system
+    # ============================================================================
+    inventory:
+      # Factory DSL errors
+      unknown_method: "Unknown method '%{method}' in treaty block for action '%{action}'. Only 'provide' method is supported. Use: provide :name, from: :source OR provide :name"
+      name_must_be_symbol: "Inventory name must be a Symbol, got %{name}. Use: provide :name, from: :source OR provide :name"
+
+      # Inventory validation errors
+      invalid_name: "Inventory name must be a non-empty Symbol, got %{name}"
+      source_required: "Inventory source cannot be nil. Provide a Symbol (method name), Proc/Lambda, or direct value"
+      evaluation_error: "Failed to evaluate inventory item '%{name}': %{error}"
+
+    # ============================================================================
+    # Executor: Inventory executor wrapper
+    # ============================================================================
+    executor:
+      inventory:
+        item_not_found: "Inventory item '%{name}' not found. Available items: %{available}"

data/lib/treaty/attribute/option/base.rb

@@ -144,14 +144,14 @@ module Treaty
         # Resolves custom message with lambda support
         # If message is a lambda, calls it with provided named arguments
         #
-        # @param context [Hash] Named arguments to pass to lambda
+        # @param attributes [Hash] Named arguments to pass to lambda
         # @return [String, nil] Resolved message string or nil
-        def resolve_custom_message(**context)
+        def resolve_custom_message(**attributes)
           message = custom_message
           return nil if message.nil?
 
           if message.respond_to?(:call)
-            message.call(**context)
+            message.call(**attributes)
           else
             message
           end

data/lib/treaty/attribute/validation/base.rb

@@ -3,18 +3,17 @@
 module Treaty
   module Attribute
     module Validation
-      # Base class for validation strategies (adapter vs non-adapter).
+      # Base class for request and response validation.
       #
       # ## Purpose
       #
-      # Provides common interface for validation strategies used in Treaty.
-      # Subclasses implement specific validation logic for different strategies.
+      # Provides common interface for validation used in Treaty.
+      # Subclasses implement specific validation logic for requests and responses.
       #
       # ## Responsibilities
       #
-      # 1. **Strategy Interface** - Defines common validation interface
+      # 1. **Validation Interface** - Defines common validation interface
       # 2. **Factory Pattern** - Provides class-level validate! method
-      # 3. **Strategy Detection** - Checks if adapter strategy is active
       #
       # ## Subclasses
       #
@@ -29,14 +28,6 @@ module Treaty
       # Example usage:
       #   Request::Validation.validate!(version_factory: factory, data: params)
       #
-      # ## Strategy Pattern
-      #
-      # The validation system supports two strategies:
-      # - **Adapter Strategy** - Adapts between different API versions
-      # - **Standard Strategy** - Direct version handling
-      #
-      # This base class provides `adapter_strategy?` helper to check current strategy.
-      #
       # ## Factory Method
       #
       # The `self.validate!(...)` class method provides a convenient factory pattern:
@@ -49,7 +40,7 @@ module Treaty
       # ## Architecture
       #
       # Works with:
-      # - VersionFactory - Provides version and strategy information
+      # - VersionFactory - Provides version information
       # - Orchestrator::Base - Performs actual validation and transformation
       class Base
         # Class-level factory method for validation
@@ -63,7 +54,7 @@ module Treaty
 
         # Creates a new validation instance
         #
-        # @param version_factory [VersionFactory] Factory containing version and strategy
+        # @param version_factory [VersionFactory] Factory containing version information
         def initialize(version_factory:)
           @version_factory = version_factory
         end
@@ -77,15 +68,6 @@ module Treaty
           raise Treaty::Exceptions::Validation,
                 I18n.t("treaty.attributes.validators.nested.orchestrator.collection_not_implemented")
         end
-
-        private
-
-        # Checks if adapter strategy is active
-        #
-        # @return [Boolean] True if using adapter strategy
-        def adapter_strategy?
-          @version_factory.strategy_instance.adapter?
-        end
       end
     end
   end

data/lib/treaty/configuration.rb

@@ -9,7 +9,7 @@ module Treaty
     attr_reader :attribute_nesting_level
 
     def initialize
-      @version = ->(context) { context }
+      @version = ->(controller) { controller }
 
       @attribute_nesting_level = 5
     end

data/lib/treaty/context/callable.rb

@@ -3,17 +3,19 @@
 module Treaty
   module Context
     module Callable
-      def call!(version:, params:)
-        context = send(:new)
+      def call!(version:, params:, context: nil, inventory: nil)
+        treaty_instance = send(:new)
 
-        _call!(context, version:, params:)
+        _call!(treaty_instance, context:, inventory:, version:, params:)
       end
 
       private
 
-      def _call!(context, version:, params:)
-        context.send(
+      def _call!(treaty_instance, context:, inventory:, version:, params:)
+        treaty_instance.send(
           :_call!,
+          context:,
+          inventory:,
           version:,
           params:,
           collection_of_versions:

data/lib/treaty/context/workspace.rb

@@ -6,11 +6,15 @@ module Treaty
       private
 
       def _call!(
+        context:,
+        inventory:,
         version:,
         params:,
         collection_of_versions:
       )
         call!(
+          context:,
+          inventory:,
           version:,
           params:,
           collection_of_versions:

data/lib/treaty/controller/dsl.rb

@@ -11,11 +11,23 @@ module Treaty
       module ClassMethods
         private
 
-        def treaty(action_name)
+        def treaty(action_name, &block) # rubocop:disable Metrics/MethodLength
+          # Capture block in a local variable before using in define_method.
+          # This is necessary because define_method creates a new closure,
+          # and the block parameter might not be accessible without explicit capture.
+          inventory_block = block
+
           define_method(action_name) do
-            treaty = treaty_class.call!(version: treaty_version, params:)
+            inventory_collection = treaty_build_inventory_for(action_name, inventory_block)
+
+            treaty_result = treaty_class.call!(
+              context: self,
+              inventory: inventory_collection,
+              version: treaty_version,
+              params:
+            )
 
-            render json: treaty.data, status: treaty.status
+            render json: treaty_result.data, status: treaty_result.status
           end
         end
       end
@@ -39,6 +51,16 @@ module Treaty
         def treaty_version
           Treaty::Engine.config.treaty.version.call(self)
         end
+
+        private
+
+        def treaty_build_inventory_for(action_name, block)
+          return nil unless block
+
+          factory = Treaty::Inventory::Factory.new(action_name)
+          factory.instance_eval(&block)
+          factory.collection
+        end
       end
     end
   end

data/lib/treaty/exceptions/base.rb

@@ -37,7 +37,6 @@ module Treaty
     # - Deprecated - API version deprecation
     # - SpecifiedVersionNotFound - No version specified and no default configured
     # - VersionNotFound - Requested version doesn't exist
-    # - Strategy - Invalid strategy specification
     # - ClassName - Treaty class not found
     # - MethodName - Unknown method in DSL
     # - NestedAttributes - Nesting depth exceeded

data/lib/treaty/exceptions/inventory.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Exceptions
+    # Raised when inventory definition or processing fails
+    #
+    # ## Purpose
+    #
+    # Indicates errors during inventory DSL processing, including invalid method calls,
+    # missing parameters, and invalid source types. Provides consistent error handling
+    # for the inventory system.
+    #
+    # ## Usage
+    #
+    # Raised in various inventory scenarios:
+    #
+    # ### Invalid DSL Method
+    # ```ruby
+    # # When calling unknown method in treaty block
+    # treaty :index do
+    #   unknown_method :something
+    # end
+    # # => Treaty::Exceptions::Inventory: Unknown method 'unknown_method' in treaty block for action 'index'
+    # ```
+    #
+    # ### Missing Required Parameters
+    # ```ruby
+    # # When 'from' parameter is missing
+    # treaty :index do
+    #   provide :posts
+    # end
+    # # => Treaty::Exceptions::Inventory: Inventory 'posts' requires 'from' parameter
+    #
+    # # When inventory name is not a symbol
+    # treaty :index do
+    #   provide "posts", from: :load_posts
+    # end
+    # # => Treaty::Exceptions::Inventory: Inventory name must be a Symbol, got "posts"
+    # ```
+    #
+    # ### Invalid Source
+    # ```ruby
+    # # When source is nil
+    # treaty :index do
+    #   provide :posts, from: nil
+    # end
+    # # => Treaty::Exceptions::Inventory: Inventory source cannot be nil
+    # ```
+    #
+    # ## Integration
+    #
+    # Can be rescued by application controllers:
+    #
+    # ```ruby
+    # rescue_from Treaty::Exceptions::Inventory, with: :render_inventory_error
+    #
+    # def render_inventory_error(exception)
+    #   render json: { error: exception.message }, status: :internal_server_error
+    # end
+    # ```
+    #
+    # ## Valid Sources
+    #
+    # - Symbol: Method name to call on controller (e.g., `:load_posts`)
+    # - Proc/Lambda: Callable object (e.g., `-> { Post.all }`)
+    # - Direct value: String, number, or any other value (e.g., `"Welcome"`)
+    class Inventory < Base
+    end
+  end
+end

data/lib/treaty/exceptions/method_name.rb

@@ -15,7 +15,6 @@ module Treaty
     #
     # ```ruby
     # version 1 do
-    #   strategy Treaty::Strategy::ADAPTER  # Valid
     #   deprecated true                     # Valid
     #   summary "Version 1"                 # Valid
     #
@@ -38,7 +37,6 @@ module Treaty
     # ## Valid DSL Methods
     #
     # Within a version block, these methods are valid:
-    # - strategy(code) - Set version strategy (DIRECT/ADAPTER)
     # - deprecated(condition) - Mark version as deprecated
     # - summary(text) - Add version description
     # - request(&block) - Define request schema

data/lib/treaty/executor/inventory.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Executor
+    # Inventory wrapper that provides method-based access to inventory items.
+    #
+    # ## Purpose
+    #
+    # Wraps inventory collection and controller context, providing lazy evaluation
+    # of inventory items through method calls. This encapsulates all inventory logic
+    # within the class and provides a clean API for services.
+    #
+    # ## Usage
+    #
+    # ```ruby
+    # # Created internally by Treaty
+    # inventory = Treaty::Executor::Inventory.new(inventory_collection, controller_context)
+    #
+    # # Access via method calls - evaluates lazily
+    # inventory.posts          # => Calls controller method or evaluates proc
+    # inventory.current_user   # => Returns evaluated value
+    #
+    # # Raises exception for missing items
+    # inventory.missing_item   # => Treaty::Exceptions::Inventory
+    #
+    # # Convert to hash - evaluates all items
+    # inventory.to_h           # => { posts: [...], current_user: ... }
+    # ```
+    #
+    # ## Architecture
+    #
+    # The class encapsulates:
+    # - Inventory collection (from controller's treaty block)
+    # - Controller context (for method calls and proc evaluation)
+    # - Lazy evaluation logic (items evaluated on access)
+    #
+    # ## Error Handling
+    #
+    # If an inventory item is not found, raises `Treaty::Exceptions::Inventory` with
+    # an I18n-translated error message listing available items.
+    class Inventory
+      # Creates a new inventory instance
+      #
+      # @param inventory [Treaty::Inventory::Collection] Collection of inventory items
+      # @param context [Object] Controller instance for evaluation
+      def initialize(inventory, context)
+        @inventory = inventory
+        @context = context
+        @evaluated_cache = {}
+      end
+
+      # Provides method-based access to inventory items with lazy evaluation
+      #
+      # @param method_name [Symbol] The inventory item name
+      # @param _args [Array] Arguments (not used, for compatibility)
+      # @return [Object] The evaluated inventory item value
+      # @raise [Treaty::Exceptions::Inventory] If item not found
+      def method_missing(method_name, *_args)
+        # Check cache first
+        return @evaluated_cache[method_name] if @evaluated_cache.key?(method_name)
+
+        # Find inventory item
+        item = find_inventory_item(method_name)
+
+        # Evaluate and cache
+        @evaluated_cache[method_name] = item.evaluate(@context)
+      end
+
+      # Checks if inventory responds to a method
+      #
+      # @param method_name [Symbol] The method name to check
+      # @param include_private [Boolean] Whether to include private methods
+      # @return [Boolean] True if inventory has the item
+      def respond_to_missing?(method_name, include_private = false)
+        return false if @inventory.nil?
+
+        @inventory.names.include?(method_name) || super
+      end
+
+      # Converts inventory to hash, evaluating all items
+      #
+      # @return [Hash] Hash of all evaluated inventory items
+      def to_h
+        return {} if @inventory.nil?
+
+        @inventory.evaluate(@context)
+      end
+
+      # Returns string representation
+      #
+      # @return [String] Inventory description
+      def inspect
+        items = @inventory&.names || []
+        "#<Treaty::Executor::Inventory items=#{items.inspect}>"
+      end
+
+      private
+
+      # Finds inventory item by name
+      #
+      # @param name [Symbol] Inventory item name
+      # @return [Treaty::Inventory::Inventory] The inventory item
+      # @raise [Treaty::Exceptions::Inventory] If not found or inventory is nil
+      def find_inventory_item(name)
+        # Use find method for cleaner search
+        item = @inventory&.find { |item| item.name == name }
+
+        return item if item
+
+        # Item not found - list available items
+        available = @inventory&.names || []
+
+        raise Treaty::Exceptions::Inventory,
+              I18n.t(
+                "treaty.executor.inventory.item_not_found",
+                name:,
+                available: available.join(", ")
+              )
+      end
+    end
+  end
+end

data/lib/treaty/info/rest/builder.rb

@@ -36,7 +36,6 @@ module Treaty
               segments: gem_version.segments,
               default: version.default_result,
               summary: version.summary_text,
-              strategy: version.strategy_instance.code,
               deprecated: version.deprecated_result,
               executor: build_executor_with(version),
               request: build_request_with(version),

data/lib/treaty/inventory/collection.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Inventory
+    # Collection wrapper for sets of inventory items.
+    #
+    # ## Purpose
+    #
+    # Provides a unified interface for working with collections of inventory items.
+    # Uses Ruby Set internally for uniqueness but exposes Array-like interface.
+    #
+    # ## Usage
+    #
+    # Used internally by:
+    # - Inventory::Factory (to store inventory items during DSL processing)
+    #
+    # ## Methods
+    #
+    # Delegates common collection methods to internal Set:
+    # - `<<` - Add inventory item
+    # - `empty?` - Check if collection is empty
+    #
+    # Custom methods:
+    # - `exists?` - Returns true if collection is not empty
+    # - `evaluate` - Evaluates all inventory items with context
+    #
+    # ## Example
+    #
+    #   collection = Collection.new
+    #   collection << Inventory.new(name: :posts, source: :load_posts)
+    #   collection << Inventory.new(name: :meta, source: -> { { count: 10 } })
+    #   collection.size  # => 2
+    #   collection.exists?  # => true
+    class Collection
+      extend Forwardable
+
+      def_delegators :@collection, :<<, :each_with_object, :find, :empty?
+
+      # Creates a new collection instance
+      #
+      # @param collection [Set] Initial collection (default: empty Set)
+      def initialize(collection = Set.new)
+        @collection = collection
+      end
+
+      # Checks if collection has any elements
+      #
+      # @return [Boolean] True if collection is not empty
+      def exists?
+        !empty?
+      end
+
+      # Returns array of all inventory item names
+      #
+      # @return [Array<Symbol>] Array of inventory item names
+      def names
+        @collection.each_with_object([]) { |item, names| names << item.name }
+      end
+
+      # Evaluates all inventory items with the given context
+      #
+      # @param context [Object] The controller instance to call methods on
+      # @return [Hash{Symbol => Object}] Hash of inventory name => resolved value
+      def evaluate(context)
+        @collection.each_with_object({}) do |inventory_item, hash|
+          hash[inventory_item.name] = inventory_item.evaluate(context)
+        end
+      end
+    end
+  end
+end

data/lib/treaty/inventory/factory.rb

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Inventory
+    # Factory for building inventory collections via DSL.
+    #
+    # ## Purpose
+    #
+    # Provides the `provide` DSL method for defining inventory items in controller blocks.
+    # Captures calls like `provide :posts, from: :load_posts` and builds a collection.
+    #
+    # ## Usage
+    #
+    # Used internally by Controller::DSL when processing treaty blocks:
+    #
+    # ```ruby
+    # treaty :index do
+    #   provide :posts, from: :load_posts       # Explicit source
+    #   provide :meta, from: -> { { count: 10 } } # Lambda source
+    #   provide :current_user                   # Shorthand: uses :current_user as source
+    # end
+    # ```
+    #
+    # ## Valid Sources
+    #
+    # - Symbol: Method name to call on controller (e.g., `:load_posts`)
+    # - Proc/Lambda: Callable object (e.g., `-> { Post.all }`)
+    # - Direct value: String, number, or any other value (e.g., `"Welcome"`)
+    # - Omitted: Uses inventory name as source (e.g., `provide :posts` → `from: :posts`)
+    #
+    # ## Invalid Sources
+    #
+    # - Direct method calls without symbol/proc (e.g., `from: load_posts`)
+    # - Explicit nil values (e.g., `from: nil`)
+    class Factory
+      attr_reader :collection
+
+      def initialize(action_name)
+        @action_name = action_name
+        @collection = Collection.new
+      end
+
+      # Handles the `provide` DSL method via method_missing
+      #
+      # @param method_name [Symbol] Should be :provide
+      # @param args [Array] First argument is the inventory name
+      # @param options [Hash] Optional :from key with source (defaults to inventory name)
+      # @return [Collection] The collection being built
+      # @raise [Treaty::Exceptions::Inventory] For invalid method or missing parameters
+      def method_missing(method_name, *args, **options, &_block) # rubocop:disable Metrics/MethodLength
+        # Only handle 'provide' method
+        unless method_name == :provide
+          raise Treaty::Exceptions::Inventory,
+                I18n.t(
+                  "treaty.inventory.unknown_method",
+                  method: method_name,
+                  action: @action_name
+                )
+        end
+
+        # Extract inventory name
+        inventory_name = args.first
+
+        unless inventory_name.is_a?(Symbol)
+          raise Treaty::Exceptions::Inventory,
+                I18n.t(
+                  "treaty.inventory.name_must_be_symbol",
+                  name: inventory_name.inspect
+                )
+        end
+
+        # Extract source from options (default to inventory name if not provided)
+        source = if options.key?(:from)
+                   options.fetch(:from)
+                 else
+                   inventory_name
+                 end
+
+        # Create and add inventory item to collection
+        @collection << Inventory.new(name: inventory_name, source:)
+
+        # Return collection for potential chaining
+        @collection
+      end
+
+      def respond_to_missing?(method_name, *)
+        method_name == :provide || super
+      end
+    end
+  end
+end

data/lib/treaty/inventory/inventory.rb

@@ -0,0 +1,92 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Inventory
+    # Represents a single inventory item that provides data to the treaty execution.
+    #
+    # An inventory item has a name and a source. The source can be:
+    # - Symbol: A method name to call on the controller (e.g., :load_posts)
+    # - Proc/Lambda: A callable object (e.g., -> { Post.all })
+    # - Direct value: Any other value to pass directly (e.g., "text", 42)
+    #
+    # ## Usage
+    #
+    # ```ruby
+    # # In controller
+    # treaty :index do
+    #   provide :posts, from: :load_posts
+    #   provide :meta, from: -> { { count: 10 } }
+    #   provide :title, from: "Welcome"
+    # end
+    # ```
+    class Inventory
+      attr_reader :name, :source
+
+      def initialize(name:, source:)
+        validate_name!(name)
+        validate_source!(source)
+
+        @name = name
+        @source = source
+      end
+
+      # Evaluates the inventory source with the given context
+      #
+      # @param context [Object] The controller instance to call methods on
+      # @return [Object] The resolved value
+      # @raise [Treaty::Exceptions::Inventory] If evaluation fails
+      def evaluate(context) # rubocop:disable Metrics/MethodLength
+        case source
+        when Symbol
+          evaluate_symbol(context)
+        when Proc
+          evaluate_proc(context)
+        else
+          source
+        end
+      rescue StandardError => e
+        raise Treaty::Exceptions::Inventory,
+              I18n.t(
+                "treaty.inventory.evaluation_error",
+                name: @name,
+                error: e.message
+              )
+      end
+
+      private
+
+      # Evaluates Symbol source by calling method on context
+      #
+      # @param context [Object] The controller instance
+      # @return [Object] The method return value
+      def evaluate_symbol(context)
+        context.send(source)
+      end
+
+      # Evaluates Proc source within controller context
+      #
+      # @param context [Object] The controller instance
+      # @return [Object] The proc return value
+      def evaluate_proc(context)
+        # Execute proc in controller context to access instance variables and methods
+        context.instance_exec(&source)
+      end
+
+      def validate_name!(name)
+        return if name.is_a?(Symbol) && !name.to_s.empty?
+
+        raise Treaty::Exceptions::Inventory,
+              I18n.t("treaty.inventory.invalid_name", name: name.inspect)
+      end
+
+      def validate_source!(source)
+        # Source must be Symbol, Proc, or any other direct value
+        # We don't allow nil as it's likely a mistake
+        return unless source.nil?
+
+        raise Treaty::Exceptions::Inventory,
+              I18n.t("treaty.inventory.source_required")
+      end
+    end
+  end
+end

data/lib/treaty/request/validator.rb

@@ -34,11 +34,10 @@ module Treaty
         end
       end
 
-      def validate_request_attributes! # rubocop:disable Metrics/MethodLength
-        return request_data unless adapter_strategy?
+      def validate_request_attributes!
         return request_data unless request_attributes_exist?
 
-        # For adapter strategy with attributes defined:
+        # Validate request attributes with orchestrator:
         orchestrator_class = Class.new(Treaty::Attribute::Validation::Orchestrator::Base) do
           define_method(:collection_of_attributes) do
             @version_factory.request_factory.collection_of_attributes
@@ -51,10 +50,6 @@ module Treaty
         )
       end
 
-      def adapter_strategy?
-        !@version_factory.strategy_instance.direct?
-      end
-
       def request_attributes_exist?
         return false if @version_factory.request_factory&.collection_of_attributes&.empty?
 

data/lib/treaty/response/validator.rb

@@ -29,7 +29,7 @@ module Treaty
       def validate_response_attributes!
         return @response_data unless response_attributes_exist?
 
-        # Create orchestrator for both DIRECT and ADAPTER strategies
+        # Create orchestrator for response validation
         # Orchestrator filters data by attributes and performs transformation
         orchestrator_class = Class.new(Treaty::Attribute::Validation::Orchestrator::Base) do
           define_method(:collection_of_attributes) do
@@ -43,10 +43,6 @@ module Treaty
         )
       end
 
-      def adapter_strategy?
-        !@version_factory.strategy_instance.direct?
-      end
-
       def response_attributes_exist?
         return false if @version_factory.response_factory&.collection_of_attributes&.empty?
 

data/lib/treaty/version.rb

@@ -3,7 +3,7 @@
 module Treaty
   module VERSION
     MAJOR = 0
-    MINOR = 11
+    MINOR = 12
     PATCH = 0
     PRE = nil
 

data/lib/treaty/versions/execution/request.rb

@@ -8,7 +8,9 @@ module Treaty
           new(...).execute!
         end
 
-        def initialize(version_factory:, validated_params:)
+        def initialize(version_factory:, validated_params:, inventory: nil, context: nil)
+          @inventory = inventory
+          @context = context
           @version_factory = version_factory
           @validated_params = validated_params
         end
@@ -89,15 +91,26 @@ module Treaty
         ########################################################################
         ########################################################################
 
+        # Creates inventory wrapper with lazy evaluation
+        #
+        # @return [Treaty::Executor::Inventory] Inventory wrapper with method-based access
+        def evaluated_inventory
+          @evaluated_inventory ||= Treaty::Executor::Inventory.new(@inventory, @context)
+        end
+
+        ########################################################################
+
         def execute_proc
-          executor.call(params: @validated_params)
+          # For Proc executors, pass inventory if collection exists
+          executor.call(**build_call_params)
         rescue StandardError => e
           raise Treaty::Exceptions::Execution,
                 I18n.t("treaty.execution.proc_error", message: e.message)
         end
 
         def execute_servactory # rubocop:disable Metrics/MethodLength
-          executor.call!(params: @validated_params)
+          # For Servactory services, pass inventory if collection exists
+          executor.call!(**build_call_params)
         rescue Servactory::Exceptions::Input => e
           raise Treaty::Exceptions::Execution,
                 I18n.t("treaty.execution.servactory_input_error", message: e.message)
@@ -124,7 +137,8 @@ module Treaty
                   )
           end
 
-          executor.public_send(method_name, params: @validated_params)
+          # For regular classes, pass inventory if collection exists
+          executor.public_send(method_name, **build_call_params)
         rescue StandardError => e
           raise Treaty::Exceptions::Execution,
                 I18n.t("treaty.execution.regular_service_error", message: e.message)
@@ -134,6 +148,17 @@ module Treaty
         ########################################################################
         ########################################################################
 
+        # Builds call parameters hash with inventory if it exists
+        #
+        # @return [Hash] Parameters hash with :params and optionally :inventory
+        def build_call_params
+          if @inventory&.exists?
+            { params: @validated_params, inventory: evaluated_inventory }
+          else
+            { params: @validated_params }
+          end
+        end
+
         def raise_executor_missing_error!
           raise Treaty::Exceptions::Execution,
                 I18n.t(

data/lib/treaty/versions/factory.rb

@@ -6,7 +6,6 @@ module Treaty
       attr_reader :version,
                   :default_result,
                   :summary_text,
-                  :strategy_instance,
                   :deprecated_result,
                   :executor,
                   :request_factory,
@@ -16,7 +15,6 @@ module Treaty
         @version = Semantic.new(version)
         @default_result = default.is_a?(Proc) ? default.call : default
         @summary_text = nil
-        @strategy_instance = Strategy.new(Strategy::ADAPTER) # without .validate!
         @deprecated_result = false
         @executor = nil
 
@@ -35,10 +33,6 @@ module Treaty
         @summary_text = text
       end
 
-      def strategy(code)
-        @strategy_instance = Strategy.new(code).validate!
-      end
-
       def deprecated(condition = nil)
         result =
           if condition.is_a?(Proc)

data/lib/treaty/versions/workspace.rb

@@ -5,7 +5,7 @@ module Treaty
     module Workspace
       private
 
-      def call!(version:, params:, **) # rubocop:disable Metrics/MethodLength
+      def call!(context:, inventory:, version:, params:, **) # rubocop:disable Metrics/MethodLength
         super
 
         version_factory = Resolver.resolve!(
@@ -19,6 +19,8 @@ module Treaty
         )
 
         executor_result = Execution::Request.execute!(
+          context:,
+          inventory:,
           version_factory:,
           validated_params:
         )

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: treaty
 version: !ruby/object:Gem::Version
-  version: 0.11.0
+  version: 0.12.0
 platform: ruby
 authors:
 - Anton Sokolov
@@ -183,22 +183,26 @@ files:
 - lib/treaty/exceptions/class_name.rb
 - lib/treaty/exceptions/deprecated.rb
 - lib/treaty/exceptions/execution.rb
+- lib/treaty/exceptions/inventory.rb
 - lib/treaty/exceptions/method_name.rb
 - lib/treaty/exceptions/nested_attributes.rb
 - lib/treaty/exceptions/not_implemented.rb
 - lib/treaty/exceptions/specified_version_not_found.rb
-- lib/treaty/exceptions/strategy.rb
 - lib/treaty/exceptions/unexpected.rb
 - lib/treaty/exceptions/validation.rb
 - lib/treaty/exceptions/version_default_deprecated_conflict.rb
 - lib/treaty/exceptions/version_multiple_defaults.rb
 - lib/treaty/exceptions/version_not_found.rb
+- lib/treaty/executor/inventory.rb
 - lib/treaty/info/entity/builder.rb
 - lib/treaty/info/entity/dsl.rb
 - lib/treaty/info/entity/result.rb
 - lib/treaty/info/rest/builder.rb
 - lib/treaty/info/rest/dsl.rb
 - lib/treaty/info/rest/result.rb
+- lib/treaty/inventory/collection.rb
+- lib/treaty/inventory/factory.rb
+- lib/treaty/inventory/inventory.rb
 - lib/treaty/request/attribute/attribute.rb
 - lib/treaty/request/attribute/builder.rb
 - lib/treaty/request/entity.rb
@@ -210,7 +214,6 @@ files:
 - lib/treaty/response/factory.rb
 - lib/treaty/response/validator.rb
 - lib/treaty/result.rb
-- lib/treaty/strategy.rb
 - lib/treaty/support/loader.rb
 - lib/treaty/version.rb
 - lib/treaty/versions/collection.rb

data/lib/treaty/exceptions/strategy.rb

@@ -1,63 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  module Exceptions
-    # Raised when an unknown or invalid strategy is specified
-    #
-    # ## Purpose
-    #
-    # Ensures only valid strategy types are used in version definitions.
-    # Prevents typos and invalid strategy configurations.
-    #
-    # ## Usage
-    #
-    # Raised when specifying an invalid strategy in version definition:
-    #
-    # ```ruby
-    # version 1 do
-    #   strategy Treaty::Strategy::ADAPTER  # Valid
-    #   strategy Treaty::Strategy::DIRECT   # Valid
-    #
-    #   strategy :invalid_strategy  # Raises Treaty::Exceptions::Strategy
-    # end
-    # ```
-    #
-    # ## Valid Strategies
-    #
-    # Only two strategies are supported:
-    #
-    # - `Treaty::Strategy::DIRECT` - Direct pass-through mode
-    #   - No transformation between service and response
-    #   - Service output becomes response output directly
-    #   - Faster but less flexible
-    #
-    # - `Treaty::Strategy::ADAPTER` - Adapter mode (default)
-    #   - Transforms service output to match response schema
-    #   - Validates and adapts data structure
-    #   - More flexible, recommended for most cases
-    #
-    # ## Integration
-    #
-    # Can be rescued by application controllers:
-    #
-    # ```ruby
-    # rescue_from Treaty::Exceptions::Strategy, with: :render_strategy_error
-    #
-    # def render_strategy_error(exception)
-    #   render json: { error: exception.message }, status: :internal_server_error
-    # end
-    # ```
-    #
-    # ## Default Behavior
-    #
-    # If no strategy is specified, ADAPTER is used by default:
-    #
-    # ```ruby
-    # version 1 do
-    #   # strategy defaults to Treaty::Strategy::ADAPTER
-    # end
-    # ```
-    class Strategy < Base
-    end
-  end
-end

data/lib/treaty/strategy.rb

@@ -1,31 +0,0 @@
-# frozen_string_literal: true
-
-module Treaty
-  class Strategy
-    DIRECT = :direct
-    ADAPTER = :adapter
-
-    LIST = [DIRECT, ADAPTER].freeze
-
-    attr_reader :code
-
-    def initialize(code)
-      @code = code
-    end
-
-    def validate!
-      return self if LIST.include?(@code)
-
-      raise Treaty::Exceptions::Strategy,
-            I18n.t("treaty.versioning.strategy.unknown", strategy: @code)
-    end
-
-    def direct?
-      @code == DIRECT
-    end
-
-    def adapter?
-      @code == ADAPTER
-    end
-  end
-end