treaty 0.11.0 → 0.13.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 6ec3d8b8448c1cb6634404040ed78864beb81a317b705a14d6f3684caaaf5952
-  data.tar.gz: a21afccd9a25da7531ff561ed4baae2cc0011ed8c9c5b09b7ceb1370b79ba353
+  metadata.gz: 600a422c9ddcdff83b3ec4cde1c8124adb8ae52e1c1d88744d8474bc4afa8c68
+  data.tar.gz: dd425b19d451b34f46b07747586f35ba7df4dcac9c554a481ac5dd27e1fe2141
 SHA512:
-  metadata.gz: 0a8281e2551007b9c6b514b3d8d664d484b27e757733dd6a94d191bfdf8cce1d50a5b4f3bdee8fb8e4cadb51b1b90802697f0cd06a929c8cf39482f6aef6c5c3
-  data.tar.gz: 1855561545ee10307c8094377ed28a132a6a9ac8f9347801f9f1d80e7f6adbb6fddc812b34e2b7960336d8558d84e9d48691aeea525c6357962b66e2a0a56e7e
+  metadata.gz: 1739edd5d1c38fe70fc6ab892b06ec15df3a665724df68c95f351675dae4e8c6a00368d65489bbfde0900a67841b9aad1e7eb57f81b948248ae902755f485519
+  data.tar.gz: 627d321a706c846e3249afb9e97f4ceb48573af52fcf962459e38316ed76ed7d979c4fd0fcffa8146cff5e7cfeab36b4cf391f9bfb3d7c82ca8de3cd6c5ea439

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

@@ -49,6 +49,17 @@ en:
         as:
           invalid_type: "Option 'as' for attribute '%{attribute}' must be a Symbol. Got: %{type}"
 
+        transform:
+          invalid_type: "Option 'transform' for attribute '%{attribute}' must be a Proc or Lambda. Got: %{type}"
+          execution_error: "Transform failed for attribute '%{attribute}': %{error}"
+
+        cast:
+          invalid_type: "Option 'cast' for attribute '%{attribute}' must be a Symbol. Got: %{type}"
+          source_not_supported: "Option 'cast' for attribute '%{attribute}' cannot be used with type '%{source_type}'. Casting is only supported for: %{allowed}"
+          target_not_supported: "Option 'cast' for attribute '%{attribute}' cannot cast to '%{target_type}'. Supported target types: %{allowed}"
+          conversion_not_supported: "Option 'cast' for attribute '%{attribute}' does not support conversion from '%{from}' to '%{to}'"
+          conversion_error: "Cast failed for attribute '%{attribute}' from '%{from}' to '%{to}'. Value: '%{value}'. Error: %{error}"
+
       # Attribute builder DSL
       builder:
         not_implemented: "%{class} must implement #create_attribute"
@@ -91,14 +102,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 +127,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/option/modifiers/cast_modifier.rb

@@ -0,0 +1,244 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Modifiers
+        # Converts attribute values between different types automatically.
+        #
+        # ## Usage Examples
+        #
+        # Simple mode:
+        #   string :created_at, cast: :datetime
+        #   datetime :timestamp, cast: :string
+        #   integer :active, cast: :boolean
+        #
+        # Advanced mode with custom error message:
+        #   string :created_at, cast: {
+        #     to: :datetime,
+        #     message: "Invalid date format"
+        #   }
+        #
+        # ## Use Cases
+        #
+        # 1. **Request type conversion**:
+        #    ```ruby
+        #    request do
+        #      string :created_at, cast: :datetime
+        #    end
+        #    # Input: { created_at: "2024-01-15T10:30:00Z" }
+        #    # Service receives: { created_at: DateTime object }
+        #    ```
+        #
+        # 2. **Response type conversion**:
+        #    ```ruby
+        #    response 200 do
+        #      datetime :created_at, cast: :string
+        #    end
+        #    # Service returns: { created_at: DateTime object }
+        #    # Output: { created_at: "2024-01-15T10:30:00Z" }
+        #    ```
+        #
+        # 3. **Unix timestamp conversion**:
+        #    ```ruby
+        #    integer :timestamp, cast: :datetime
+        #    datetime :created_at, cast: :integer
+        #    ```
+        #
+        # ## Supported Conversions
+        #
+        # ### From Integer
+        # - integer -> string: Converts to string representation
+        # - integer -> boolean: 0 = false, non-zero = true
+        # - integer -> datetime: Treats as Unix timestamp
+        #
+        # ### From String
+        # - string -> integer: Parses integer from string
+        # - string -> boolean: Parses truthy/falsy strings (true/false, yes/no, 1/0, on/off)
+        # - string -> datetime: Parses datetime string (ISO8601, RFC3339, etc.)
+        #
+        # ### From Boolean
+        # - boolean -> string: Converts to "true" or "false"
+        # - boolean -> integer: true = 1, false = 0
+        #
+        # ### From DateTime
+        # - datetime -> string: Converts to ISO8601 format
+        # - datetime -> integer: Converts to Unix timestamp
+        #
+        # ## Important Notes
+        #
+        # - Cast option only works with scalar types (integer, string, boolean, datetime)
+        # - Array and Object types are not supported for casting
+        # - Casting to the same type is allowed (no-op)
+        # - Nil values are not transformed (handled by RequiredValidator)
+        # - All conversion errors are caught and re-raised as Validation errors
+        #
+        # ## Error Handling
+        #
+        # If conversion fails (e.g., invalid date string, non-numeric string to integer),
+        # the error is caught and converted to a Treaty::Exceptions::Validation error.
+        #
+        # ## Advanced Mode
+        #
+        # Schema format: `{ to: :target_type, message: "Custom error" }`
+        # Note: Uses `:to` key instead of the default `:is` key.
+        class CastModifier < Treaty::Attribute::Option::Base
+          # Types that support casting (scalar types only)
+          ALLOWED_CAST_TYPES = %i[integer string boolean datetime].freeze
+
+          # Validates that cast option is correctly configured
+          #
+          # @raise [Treaty::Exceptions::Validation] If cast configuration is invalid
+          # @return [void]
+          def validate_schema! # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            # If option_schema is nil, cast is not used for this attribute
+            return if @option_schema.nil?
+
+            target_type = option_value
+
+            # Validate that target type is a Symbol
+            unless target_type.is_a?(Symbol)
+              raise Treaty::Exceptions::Validation,
+                    I18n.t(
+                      "treaty.attributes.modifiers.cast.invalid_type",
+                      attribute: @attribute_name,
+                      type: target_type.class
+                    )
+            end
+
+            # Validate that source type supports casting
+            unless ALLOWED_CAST_TYPES.include?(@attribute_type)
+              raise Treaty::Exceptions::Validation,
+                    I18n.t(
+                      "treaty.attributes.modifiers.cast.source_not_supported",
+                      attribute: @attribute_name,
+                      source_type: @attribute_type,
+                      allowed: ALLOWED_CAST_TYPES.join(", ")
+                    )
+            end
+
+            # Validate that target type is allowed
+            unless ALLOWED_CAST_TYPES.include?(target_type)
+              raise Treaty::Exceptions::Validation,
+                    I18n.t(
+                      "treaty.attributes.modifiers.cast.target_not_supported",
+                      attribute: @attribute_name,
+                      target_type:,
+                      allowed: ALLOWED_CAST_TYPES.join(", ")
+                    )
+            end
+
+            # Validate that conversion from source to target is supported
+            return if conversion_supported?(@attribute_type, target_type)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.modifiers.cast.conversion_not_supported",
+                    attribute: @attribute_name,
+                    from: @attribute_type,
+                    to: target_type
+                  )
+          end
+
+          # Applies type conversion to the value
+          # Skips conversion for nil values (handled by RequiredValidator)
+          #
+          # @param value [Object] The current value
+          # @return [Object] Converted value
+          def transform_value(value) # rubocop:disable Metrics/MethodLength
+            return value if value.nil? # Cast doesn't modify nil, required validator handles it.
+
+            target_type = option_value
+            conversion_lambda = conversion_matrix.dig(@attribute_type, target_type)
+
+            # Call conversion lambda
+            conversion_lambda.call(value:)
+          rescue StandardError => e
+            attributes = {
+              attribute: @attribute_name,
+              from: @attribute_type,
+              to: target_type,
+              value:,
+              error: e.message
+            }
+
+            # Catch all exceptions from conversion execution
+            error_message = resolve_custom_message(**attributes) || I18n.t(
+              "treaty.attributes.modifiers.cast.conversion_error",
+              **attributes
+            )
+
+            raise Treaty::Exceptions::Validation, error_message
+          end
+
+          protected
+
+          # Override value_key to use :to instead of :is
+          # This makes advanced mode syntax: cast: { to: :datetime }
+          #
+          # @return [Symbol] The key :to
+          def value_key
+            :to
+          end
+
+          private
+
+          # Checks if conversion from source type to target type is supported
+          #
+          # @param from_type [Symbol] Source type
+          # @param to_type [Symbol] Target type
+          # @return [Boolean] True if conversion is supported
+          def conversion_supported?(from_type, to_type)
+            conversion_matrix.dig(from_type, to_type).present?
+          end
+
+          # Matrix of all supported type conversions
+          # Maps from_type => to_type => conversion_lambda
+          #
+          # @return [Hash] Conversion matrix
+          def conversion_matrix # rubocop:disable Metrics/MethodLength, Metrics/AbcSize
+            @conversion_matrix ||= {
+              integer: {
+                integer: ->(value:) { value }, # No-op for same type
+                string: ->(value:) { value.to_s },
+                boolean: ->(value:) { value != 0 },
+                datetime: ->(value:) { Time.at(value) }
+              },
+              string: {
+                string: ->(value:) { value }, # No-op for same type
+                integer: ->(value:) { Integer(value) },
+                boolean: ->(value:) { parse_boolean(value) },
+                datetime: ->(value:) { DateTime.parse(value) }
+              },
+              boolean: {
+                boolean: ->(value:) { value }, # No-op for same type
+                string: ->(value:) { value.to_s },
+                integer: ->(value:) { value ? 1 : 0 }
+              },
+              datetime: {
+                datetime: ->(value:) { value }, # No-op for same type
+                string: ->(value:) { value.iso8601 },
+                integer: ->(value:) { value.to_i }
+              }
+            }
+          end
+
+          # Parses a string value into a boolean
+          # Recognizes: true/false, yes/no, 1/0, on/off (case-insensitive)
+          #
+          # @param value [String] The string value to parse
+          # @return [Boolean] Parsed boolean value
+          # @raise [ArgumentError] If string is not a recognized boolean value
+          def parse_boolean(value)
+            normalized = value.to_s.downcase.strip
+
+            return true if %w[true 1 yes on].include?(normalized)
+            return false if %w[false 0 no off].include?(normalized)
+
+            raise ArgumentError, "Cannot convert '#{value}' to boolean"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/treaty/attribute/option/modifiers/transform_modifier.rb

@@ -0,0 +1,111 @@
+# frozen_string_literal: true
+
+module Treaty
+  module Attribute
+    module Option
+      module Modifiers
+        # Transforms attribute values using custom lambda functions.
+        #
+        # ## Usage Examples
+        #
+        # Simple mode:
+        #   integer :amount, transform: ->(value:) { value * 100 }
+        #   string :title, transform: ->(value:) { value.strip.upcase }
+        #
+        # Advanced mode with custom error message:
+        #   integer :amount, transform: {
+        #     is: ->(value:) { value * 100 },
+        #     message: "Failed to transform amount"
+        #   }
+        #
+        # ## Use Cases
+        #
+        # 1. **Request transformation**:
+        #    ```ruby
+        #    request do
+        #      integer :amount_cents, transform: ->(value:) { value * 100 }
+        #    end
+        #    # Input: { amount_cents: 10 }
+        #    # Service receives: { amount_cents: 1000 }
+        #    ```
+        #
+        # 2. **Response transformation**:
+        #    ```ruby
+        #    response 200 do
+        #      string :title, transform: ->(value:) { value.titleize }
+        #    end
+        #    # Service returns: { title: "hello world" }
+        #    # Output: { title: "Hello World" }
+        #    ```
+        #
+        # 3. **Complex transformations**:
+        #    ```ruby
+        #    string :email, transform: ->(value:) { value.downcase.strip }
+        #    datetime :timestamp, transform: ->(value:) { value.iso8601 }
+        #    ```
+        #
+        # ## Important Notes
+        #
+        # - Lambda must accept named argument `value:`
+        # - All exceptions raised in lambda are caught and re-raised as Validation errors
+        # - Transformation is applied during Phase 3 (after validation)
+        # - Can be combined with other options (required, default, as, etc.)
+        #
+        # ## Error Handling
+        #
+        # If the lambda raises any exception, it's caught and converted to a
+        # Treaty::Exceptions::Validation with appropriate error message.
+        #
+        # ## Advanced Mode
+        #
+        # Schema format: `{ is: lambda, message: nil }`
+        class TransformModifier < Treaty::Attribute::Option::Base
+          # Validates that transform value is a lambda
+          #
+          # @raise [Treaty::Exceptions::Validation] If transform is not a Proc/lambda
+          # @return [void]
+          def validate_schema!
+            transform_lambda = option_value
+
+            return if transform_lambda.respond_to?(:call)
+
+            raise Treaty::Exceptions::Validation,
+                  I18n.t(
+                    "treaty.attributes.modifiers.transform.invalid_type",
+                    attribute: @attribute_name,
+                    type: transform_lambda.class
+                  )
+          end
+
+          # Applies transformation to the value using the provided lambda
+          # Catches all exceptions and re-raises as Validation errors
+          # Skips transformation for nil values (handled by RequiredValidator)
+          #
+          # @param value [Object] The current value
+          # @return [Object] Transformed value
+          def transform_value(value) # rubocop:disable Metrics/MethodLength
+            return value if value.nil? # Transform doesn't modify nil, required validator handles it.
+
+            transform_lambda = option_value
+
+            # Call lambda with named argument
+            transform_lambda.call(value:)
+          rescue StandardError => e
+            attributes = {
+              attribute: @attribute_name,
+              error: e.message
+            }
+
+            # Catch all exceptions from lambda execution
+            error_message = resolve_custom_message(**attributes) || I18n.t(
+              "treaty.attributes.modifiers.transform.execution_error",
+              **attributes
+            )
+
+            raise Treaty::Exceptions::Validation, error_message
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -27,6 +27,8 @@ module Treaty
       #
       # - `:as` → AsModifier - Renames attributes
       # - `:default` → DefaultModifier - Provides default values
+      # - `:transform` → TransformModifier - Transforms values using custom lambdas
+      # - `:cast` → CastModifier - Converts values between types automatically
       #
       # ## Auto-Registration
       #
@@ -81,6 +83,8 @@ module Treaty
           def register_modifiers!
             Registry.register(:as, Modifiers::AsModifier, category: :modifier)
             Registry.register(:default, Modifiers::DefaultModifier, category: :modifier)
+            Registry.register(:transform, Modifiers::TransformModifier, category: :modifier)
+            Registry.register(:cast, Modifiers::CastModifier, category: :modifier)
           end
         end
       end

data/lib/treaty/attribute/option_normalizer.rb

@@ -70,7 +70,8 @@ module Treaty
       OPTION_KEY_MAPPING = {
         in: { advanced_key: :inclusion, value_key: :in },
         as: { advanced_key: :as, value_key: :is },
-        default: { advanced_key: :default, value_key: :is }
+        default: { advanced_key: :default, value_key: :is },
+        cast: { advanced_key: :cast, value_key: :to }
       }.freeze
       private_constant :OPTION_KEY_MAPPING
 

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/attribute/validation/nested_transformer.rb

@@ -138,8 +138,7 @@ module Treaty
           def transform(value)
             value.each_with_index.map do |item, index|
               if simple_array?
-                validate_simple_element(item, index)
-                item
+                transform_simple_element(item, index)
               else
                 transform_array_item(item, index)
               end
@@ -156,19 +155,21 @@ module Treaty
               attribute.collection_of_attributes.first.name == SELF_OBJECT
           end
 
-          # Validates a simple array element (primitive value)
+          # Transforms a simple array element (primitive value)
+          # Validates and applies transformations to the element
           #
-          # @param item [Object] Array element to validate
+          # @param item [Object] Array element to transform
           # @param index [Integer] Element index for error messages
           # @raise [Treaty::Exceptions::Validation] If validation fails
-          # @return [void]
-          def validate_simple_element(item, index) # rubocop:disable Metrics/MethodLength
+          # @return [Object] Transformed element value
+          def transform_simple_element(item, index) # rubocop:disable Metrics/MethodLength
             self_attr = attribute.collection_of_attributes.first
             validator = AttributeValidator.new(self_attr)
             validator.validate_schema!
 
             begin
               validator.validate_value!(item)
+              validator.transform_value(item)
             rescue Treaty::Exceptions::Validation => e
               raise Treaty::Exceptions::Validation,
                     I18n.t(

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: