servactory 3.1.0.rc1 → 3.1.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1c4398d2ffb193d4acd86b96f02871198d13d4e8b31ec96dddaa05c3966f1525
-  data.tar.gz: bf35a15c0d771ef1c6362d573e2fbd5a04a0021cb0a80d847f37b23d5dff3b76
+  metadata.gz: c5acfb374e0e85d7779b99658fcb899007ca346ca63c71344800490428ac61dd
+  data.tar.gz: 94ff484e768908909aa856d63310af3c896f198357b88c3089fe9393de53bc88
 SHA512:
-  metadata.gz: baa8f5c12c6edbf0786d807611a759f8fd54b3f087967ea981942843e3a19b2f1026f607bc52ad9c5f4dd42830216582e4e54d38bef5e00fa48dea47bbe84210
-  data.tar.gz: c8af2b260386c4c2711a6b034bb116ad843cfb57c5e2b3181d59e9b9d38692ec562afc69bd5b33b46820c20972c0904e9921dfd1516e1576ec8622439ae1b382
+  metadata.gz: 61facdd48b89752c3f2bfe0735c87c24f83c225c2474608c9aa871f150003a996b2b4775ef25941f0916f45524383cdf1e1814a237b522add763782c2ec03e9b
+  data.tar.gz: 13202fe9276b8323cd83fc2c0919613eeabfd9d99b4d1cfac541ef7ed88739a84c6d5719a44ca76fe960c33aaf6a66b1b9c9353e12a1e5662b8e19df05a68fd3

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Anton Sokolov
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -52,7 +52,7 @@ gem "servactory"
 ### Define service
 
 ```ruby
-class UserService::Authenticate < Servactory::Base
+class Users::Authenticate < Servactory::Base
   input :email, type: String
   input :password, type: String
 
@@ -77,7 +77,7 @@ end
 ```ruby
 class SessionsController < ApplicationController
   def create
-    service = UserService::Authenticate.call(**session_params)
+    service = Users::Authenticate.call(**session_params)
 
     if service.success?
       session[:current_user_id] = service.user.id

data/config/locales/ja.yml

@@ -0,0 +1,134 @@
+ja:
+  servactory:
+    common:
+      undefined_method:
+        missing_name: "[%{service_class_name}] %{error_text}"
+    methods:
+      call:
+        not_used: "[%{service_class_name}] 実行する処理がありません。`make`を使用するか、`call`メソッドを作成してください。"
+      cannot_be_overwritten: "[%{service_class_name}] 次のメソッドは上書きできません: %{list_of_methods}"
+    inputs:
+      undefined:
+        for_fetch: "[%{service_class_name}] 未定義の入力`%{input_name}`"
+        for_assign: "[%{service_class_name}] 未定義の入力`%{input_name}`"
+      validations:
+        must:
+          default_error: "[%{service_class_name}] 入力`%{input_name}`は「%{code}」を満たす必要があります"
+          syntax_error: "[%{service_class_name}] 入力`%{input_name}`の`%{code}`内の構文エラー: %{exception_message}"
+          dynamic_options:
+            consists_of:
+              required: "[%{service_class_name}] 入力コレクション`%{input_name}`の必須要素が不足しています"
+              wrong_type: "[%{service_class_name}] 入力コレクション`%{input_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_type: "[%{service_class_name}] 入力コレクション`%{input_name}`の要素の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+            format:
+              default: "[%{service_class_name}] 入力`%{input_name}`は`%{format_name}`フォーマットに一致しません"
+              wrong_pattern: "[%{service_class_name}] 入力`%{input_name}`は`%{format_name}`フォーマットに一致しません"
+              wrong_type: "[%{service_class_name}] 入力`%{input_name}`は`%{format_name}`フォーマット検証のためにStringである必要があります"
+              unknown: "[%{service_class_name}] 入力`%{input_name}`に指定された`%{format_name}`フォーマットは不明です"
+            inclusion:
+              default: "[%{service_class_name}] `%{input_name}`の値が不正です。`%{input_inclusion}`のいずれかである必要がありますが、`%{value}`が渡されました"
+              invalid_option: "[%{service_class_name}] 入力`%{input_name}`の`%{option_name}`オプションに値がありません"
+            min:
+              default: "[%{service_class_name}] 入力`%{input_name}`は値`%{value}`を受け取りましたが、`%{option_value}`より小さいです"
+            max:
+              default: "[%{service_class_name}] 入力`%{input_name}`は値`%{value}`を受け取りましたが、`%{option_value}`より大きいです"
+            multiple_of:
+              default: "[%{service_class_name}] 入力`%{input_name}`の値`%{value}`は`%{option_value}`の倍数ではありません"
+              blank: "[%{service_class_name}] 入力`%{input_name}`の`%{option_name}`オプションに無効な値`%{option_value}`があります"
+              divided_by_0: "[%{service_class_name}] 入力`%{input_name}`の`%{option_name}`オプションに無効な値`%{option_value}`があります"
+            schema:
+              wrong_type: "[%{service_class_name}] 入力`%{input_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_type: "[%{service_class_name}] 入力ハッシュ`%{input_name}`の型が不正です。`%{key_name}`には`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_value: "[%{service_class_name}] 入力ハッシュ`%{input_name}`の値が不正です。`%{key_name}`には`%{expected_type}`型の値が期待されましたが、`%{given_type}`が渡されました"
+            target:
+              default: "[%{service_class_name}] 入力`%{input_name}`のターゲットが不正です。`%{expected_target}`である必要がありますが、`%{value}`が渡されました"
+              invalid_option: "[%{service_class_name}] 入力`%{input_name}`の`%{option_name}`オプションに値がありません"
+        required:
+          default_error:
+            default: "[%{service_class_name}] 必須の入力`%{input_name}`が不足しています"
+        type:
+          default_error:
+            default: "[%{service_class_name}] 入力`%{input_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+      tools:
+        find_unnecessary:
+          error: "[%{service_class_name}] 予期しない属性: `%{unnecessary_attributes}`"
+        rules:
+          error: "[%{service_class_name}] 入力`%{input_name}`のオプションに競合があります: `%{conflict_code}`"
+    internals:
+      undefined:
+        for_fetch: "[%{service_class_name}] 未定義の内部属性`%{internal_name}`"
+        for_assign: "[%{service_class_name}] 未定義の内部属性`%{internal_name}`"
+      validations:
+        must:
+          default_error: "[%{service_class_name}] 内部属性`%{internal_name}`は「%{code}」を満たす必要があります"
+          syntax_error: "[%{service_class_name}] 内部属性`%{internal_name}`の`%{code}`内の構文エラー: %{exception_message}"
+          dynamic_options:
+            consists_of:
+              required: "[%{service_class_name}] 内部属性コレクション`%{internal_name}`の必須要素が不足しています"
+              wrong_type: "[%{service_class_name}] 内部属性コレクション`%{internal_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_type: "[%{service_class_name}] 内部属性コレクション`%{internal_name}`の要素の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+            format:
+              default: "[%{service_class_name}] 内部属性`%{internal_name}`は`%{format_name}`フォーマットに一致しません"
+              wrong_pattern: "[%{service_class_name}] 内部属性`%{internal_name}`は`%{format_name}`フォーマットに一致しません"
+              wrong_type: "[%{service_class_name}] 内部属性`%{internal_name}`は`%{format_name}`フォーマット検証のためにStringである必要があります"
+              unknown: "[%{service_class_name}] 内部属性`%{internal_name}`に指定された`%{format_name}`フォーマットは不明です"
+            inclusion:
+              default: "[%{service_class_name}] `%{internal_name}`の値が不正です。`%{internal_inclusion}`のいずれかである必要がありますが、`%{value}`が渡されました"
+              invalid_option: "[%{service_class_name}] 内部属性`%{internal_name}`の`%{option_name}`オプションに値がありません"
+            min:
+              default: "[%{service_class_name}] 内部属性`%{internal_name}`は値`%{value}`を受け取りましたが、`%{option_value}`より小さいです"
+            max:
+              default: "[%{service_class_name}] 内部属性`%{internal_name}`は値`%{value}`を受け取りましたが、`%{option_value}`より大きいです"
+            multiple_of:
+              default: "[%{service_class_name}] 内部属性`%{internal_name}`の値`%{value}`は`%{option_value}`の倍数ではありません"
+              blank: "[%{service_class_name}] 内部属性`%{internal_name}`の`%{option_name}`オプションに無効な値`%{option_value}`があります"
+              divided_by_0: "[%{service_class_name}] 内部属性`%{internal_name}`の`%{option_name}`オプションに無効な値`%{option_value}`があります"
+            schema:
+              wrong_type: "[%{service_class_name}] 内部属性`%{internal_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_type: "[%{service_class_name}] 内部属性ハッシュ`%{internal_name}`の型が不正です。`%{key_name}`には`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_value: "[%{service_class_name}] 内部属性ハッシュ`%{internal_name}`の値が不正です。`%{key_name}`には`%{expected_type}`型の値が期待されましたが、`%{given_type}`が渡されました"
+            target:
+              default: "[%{service_class_name}] 内部属性`%{internal_name}`のターゲットが不正です。`%{expected_target}`である必要がありますが、`%{value}`が渡されました"
+              invalid_option: "[%{service_class_name}] 内部属性`%{internal_name}`の`%{option_name}`オプションに値がありません"
+        type:
+          default_error:
+            default: "[%{service_class_name}] 内部属性`%{internal_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+    outputs:
+      undefined:
+        for_fetch: "[%{service_class_name}] 未定義の出力属性`%{output_name}`"
+        for_assign: "[%{service_class_name}] 未定義の出力属性`%{output_name}`"
+      validations:
+        must:
+          default_error: "[%{service_class_name}] 出力属性`%{output_name}`は「%{code}」を満たす必要があります"
+          syntax_error: "[%{service_class_name}] 出力属性`%{output_name}`の`%{code}`内の構文エラー: %{exception_message}"
+          dynamic_options:
+            consists_of:
+              required: "[%{service_class_name}] 出力属性コレクション`%{output_name}`の必須要素が不足しています"
+              wrong_type: "[%{service_class_name}] 出力属性コレクション`%{output_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_type: "[%{service_class_name}] 出力属性コレクション`%{output_name}`の要素の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+            format:
+              default: "[%{service_class_name}] 出力属性`%{output_name}`は`%{format_name}`フォーマットに一致しません"
+              wrong_pattern: "[%{service_class_name}] 出力属性`%{output_name}`は`%{format_name}`フォーマットに一致しません"
+              wrong_type: "[%{service_class_name}] 出力属性`%{output_name}`は`%{format_name}`フォーマット検証のためにStringである必要があります"
+              unknown: "[%{service_class_name}] 出力属性`%{output_name}`に指定された`%{format_name}`フォーマットは不明です"
+            inclusion:
+              default: "[%{service_class_name}] `%{output_name}`の値が不正です。`%{output_inclusion}`のいずれかである必要がありますが、`%{value}`が渡されました"
+              invalid_option: "[%{service_class_name}] 出力属性`%{output_name}`の`%{option_name}`オプションに値がありません"
+            min:
+              default: "[%{service_class_name}] 出力属性`%{output_name}`は値`%{value}`を受け取りましたが、`%{option_value}`より小さいです"
+            max:
+              default: "[%{service_class_name}] 出力属性`%{output_name}`は値`%{value}`を受け取りましたが、`%{option_value}`より大きいです"
+            multiple_of:
+              default: "[%{service_class_name}] 出力属性`%{output_name}`の値`%{value}`は`%{option_value}`の倍数ではありません"
+              blank: "[%{service_class_name}] 出力属性`%{output_name}`の`%{option_name}`オプションに無効な値`%{option_value}`があります"
+              divided_by_0: "[%{service_class_name}] 出力属性`%{output_name}`の`%{option_name}`オプションに無効な値`%{option_value}`があります"
+            schema:
+              wrong_type: "[%{service_class_name}] 出力属性`%{output_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_type: "[%{service_class_name}] 出力属性ハッシュ`%{output_name}`の型が不正です。`%{key_name}`には`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"
+              wrong_element_value: "[%{service_class_name}] 出力属性ハッシュ`%{output_name}`の値が不正です。`%{key_name}`には`%{expected_type}`型の値が期待されましたが、`%{given_type}`が渡されました"
+            target:
+              default: "[%{service_class_name}] 出力属性`%{output_name}`のターゲットが不正です。`%{expected_target}`である必要がありますが、`%{value}`が渡されました"
+              invalid_option: "[%{service_class_name}] 出力属性`%{output_name}`の`%{option_name}`オプションに値がありません"
+        type:
+          default_error:
+            default: "[%{service_class_name}] 出力属性`%{output_name}`の型が不正です。`%{expected_type}`が期待されましたが、`%{given_type}`が渡されました"

data/lib/generators/README.md

@@ -9,7 +9,7 @@ rails generate servactory:install [options]
 **Options:**
 - `--namespace` — Base namespace (default: `ApplicationService`)
 - `--path` — Path to install service files (default: `app/services`)
-- `--locales` — Locales to install (available: `en`, `ru`, `de`, `fr`, `es`, `it`)
+- `--locales` — Locales to install (available: `en`, `ru`, `de`, `fr`, `es`, `it`, `ja`)
 - `--minimal` — Generate minimal setup without configuration examples
 
 ## Service

data/lib/servactory/configuration/config.rb

@@ -30,6 +30,22 @@ module Servactory
         @collection_mode_class_names = original.collection_mode_class_names.dup
         @hash_mode_class_names = original.hash_mode_class_names.dup
         @action_rescue_handlers = original.action_rescue_handlers.dup
+
+        rebind_dynamic_option_helpers!
+      end
+
+      private
+
+      def rebind_dynamic_option_helpers!
+        new_consists_of = Servactory::ToolKit::DynamicOptions::ConsistsOf
+                          .use(collection_mode_class_names: @collection_mode_class_names)
+        new_schema = Servactory::ToolKit::DynamicOptions::Schema
+                     .use(default_hash_mode_class_names: @hash_mode_class_names)
+
+        [@input_option_helpers, @internal_option_helpers, @output_option_helpers].each do |helpers|
+          helpers.replace(name: :consists_of, with: new_consists_of)
+          helpers.replace(name: :schema, with: new_schema)
+        end
       end
     end
   end

data/lib/servactory/configuration/configurable.rb

@@ -67,7 +67,8 @@ module Servactory
             .new(name: :optional, equivalent: { required: false }),
             Servactory::ToolKit::DynamicOptions::ConsistsOf
               .use(collection_mode_class_names: config.collection_mode_class_names),
-            Servactory::ToolKit::DynamicOptions::Schema.use(default_hash_mode_class_names:),
+            Servactory::ToolKit::DynamicOptions::Schema
+              .use(default_hash_mode_class_names: config.hash_mode_class_names),
             Servactory::ToolKit::DynamicOptions::Inclusion.use
           ]
         end
@@ -76,7 +77,8 @@ module Servactory
           Set[
             Servactory::ToolKit::DynamicOptions::ConsistsOf
             .use(collection_mode_class_names: config.collection_mode_class_names),
-            Servactory::ToolKit::DynamicOptions::Schema.use(default_hash_mode_class_names:),
+            Servactory::ToolKit::DynamicOptions::Schema
+              .use(default_hash_mode_class_names: config.hash_mode_class_names),
             Servactory::ToolKit::DynamicOptions::Inclusion.use
           ]
         end
@@ -85,7 +87,8 @@ module Servactory
           Set[
             Servactory::ToolKit::DynamicOptions::ConsistsOf
             .use(collection_mode_class_names: config.collection_mode_class_names),
-            Servactory::ToolKit::DynamicOptions::Schema.use(default_hash_mode_class_names:),
+            Servactory::ToolKit::DynamicOptions::Schema
+              .use(default_hash_mode_class_names: config.hash_mode_class_names),
             Servactory::ToolKit::DynamicOptions::Inclusion.use
           ]
         end

data/lib/servactory/configuration/hash_mode/class_names_collection.rb

@@ -6,7 +6,10 @@ module Servactory
       class ClassNamesCollection
         extend Forwardable
 
-        def_delegators :@collection, :include?, :intersect?
+        def_delegators :@collection,
+                       :merge,
+                       :include?,
+                       :intersect?
 
         def initialize(collection)
           @collection = collection

data/lib/servactory/configuration/option_helpers/option_helpers_collection.rb

@@ -72,6 +72,20 @@ module Servactory
           helpers_index[name]
         end
 
+        # Replaces a helper by name with a new one, invalidating the index cache.
+        #
+        # @param name [Symbol] the helper name to replace
+        # @param with [Maintenance::Attributes::OptionHelper] the replacement helper
+        # @return [void]
+        def replace(name:, with:)
+          old = find_by(name:)
+          return unless old
+
+          @collection.delete(old)
+          @collection.add(with)
+          @helpers_index = nil
+        end
+
         private
 
         # Builds and caches a hash index for O(1) helper lookups.

data/lib/servactory/context/warehouse/inputs.rb

@@ -29,55 +29,42 @@ module Servactory
           @arguments.keys
         end
 
-        # Merges new arguments into storage and defines accessor methods.
+        # Merges new arguments into storage.
         #
         # @param arguments [Hash] Input name-value pairs to merge
-        # @return [void]
+        # @return [Hash] Updated arguments hash
         def merge!(arguments)
           @arguments.merge!(arguments)
-          define_methods_for!(arguments)
         end
 
-        # Raises error for any method call not pre-defined as a singleton accessor.
+        # Delegates method calls to stored inputs.
         #
         # Supports predicate methods when enabled in config.
         #
         # @param name [Symbol] Method name (input or predicate)
         # @param _args [Array] Method arguments (unused)
-        # @raise [Exception] Failure exception for undefined input
+        # @return [Object] Input value or predicate result
         def method_missing(name, *_args)
           predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
+
           input_name = predicate ? name.to_s.chomp("?").to_sym : name
-          raise_error_for(input_name)
+
+          input_value = @arguments.fetch(input_name) { raise_error_for(input_name) }
+
+          predicate ? Servactory::Utils.query_attribute(input_value) : input_value
         end
 
-        # Returns false since all valid methods are defined as singleton methods.
+        # Checks if method corresponds to stored input.
         #
-        # @return [Boolean] Always false
-        def respond_to_missing?(*)
-          false
+        # @param name [Symbol] Method name to check
+        # @return [Boolean] True if input exists for this method
+        def respond_to_missing?(name, *)
+          input_name = name.to_s.chomp("?").to_sym
+          @arguments.key?(input_name) || @arguments.key?(name) || super
         end
 
         private
 
-        # Defines singleton accessor methods for given arguments.
-        #
-        # @param arguments [Hash] Input name-value pairs to define methods for
-        # @return [void]
-        def define_methods_for!(arguments)
-          arguments.each_key do |name|
-            define_singleton_method(name) do
-              @arguments.fetch(name) { raise_error_for(name) }
-            end
-
-            next unless @context.config.predicate_methods_enabled
-
-            define_singleton_method(:"#{name}?") do
-              Servactory::Utils.query_attribute(@arguments.fetch(name) { raise_error_for(name) })
-            end
-          end
-        end
-
         # Raises error for undefined input.
         #
         # @param input_name [Symbol] Name of undefined input

data/lib/servactory/context/workspace/inputs.rb

@@ -7,8 +7,6 @@ module Servactory
         def initialize(context:, collection_of_inputs:)
           @context = context
           @collection_of_inputs = collection_of_inputs
-
-          define_attribute_methods!
         end
 
         def only(*names)
@@ -26,30 +24,31 @@ module Servactory
         def method_missing(name, *_args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
+
             raise_error_for(:assign, prepared_name)
           else
-            raise_error_for(:fetch, name)
+            fetch_with(name:) { raise_error_for(:fetch, name) }
           end
         end
 
-        def respond_to_missing?(*)
-          false
+        def respond_to_missing?(name, *)
+          resolve_input(name) || super
         end
 
         private
 
-        def define_attribute_methods!
-          @collection_of_inputs.each do |input|
-            define_singleton_method(input.internal_name) do
-              fetch_value(attribute: input)
-            end
+        def fetch_with(name:, &_block)
+          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
 
-            next unless @context.config.predicate_methods_enabled
+          input_name = predicate ? name.to_s.chomp("?").to_sym : name
 
-            define_singleton_method(:"#{input.internal_name}?") do
-              fetch_predicate(attribute: input)
-            end
-          end
+          input = @collection_of_inputs.find_by(name: input_name)
+
+          return yield if input.nil?
+
+          value = fetch_value(attribute: input)
+
+          predicate ? Servactory::Utils.query_attribute(value) : value
         end
 
         def fetch_value(attribute:)
@@ -65,8 +64,12 @@ module Servactory
           value
         end
 
-        def fetch_predicate(attribute:)
-          Servactory::Utils.query_attribute(fetch_value(attribute:))
+        def resolve_input(name)
+          return true if @collection_of_inputs.find_by(name:)
+
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_inputs.find_by(name: name.to_s.chomp("?").to_sym)
         end
 
         def raise_error_for(type, name)

data/lib/servactory/context/workspace/internals.rb

@@ -7,9 +7,6 @@ module Servactory
         def initialize(context:, collection_of_internals:)
           @context = context
           @collection_of_internals = collection_of_internals
-          @validated_attributes = Set.new
-
-          define_attribute_methods!
         end
 
         def only(*names)
@@ -24,57 +21,61 @@ module Servactory
             .to_h { |internal| [internal.name, send(internal.name)] }
         end
 
-        def method_missing(name, *_args)
+        def method_missing(name, *args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
-            raise_error_for(:assign, prepared_name)
+
+            assign_with(prepared_name:, value: args.pop) { raise_error_for(:assign, prepared_name) }
           else
-            raise_error_for(:fetch, name)
+            fetch_with(name:) { raise_error_for(:fetch, name) }
           end
         end
 
-        def respond_to_missing?(*)
-          false
+        def respond_to_missing?(name, *)
+          resolve_internal(name) || super
         end
 
         private
 
-        def define_attribute_methods! # rubocop:disable Metrics/MethodLength
-          @collection_of_internals.each do |internal|
-            define_singleton_method(internal.name) do
-              fetch_value(attribute: internal)
-            end
+        def validated_attributes
+          @validated_attributes ||= Set.new
+        end
 
-            define_singleton_method(:"#{internal.name}=") do |value|
-              assign_value(attribute: internal, value:)
-            end
+        def assign_with(prepared_name:, value:, &_block)
+          internal = @collection_of_internals.find_by(name: prepared_name)
 
-            next unless @context.config.predicate_methods_enabled
+          return yield if internal.nil?
 
-            define_singleton_method(:"#{internal.name}?") do
-              fetch_predicate(attribute: internal)
-            end
-          end
-        end
-
-        def assign_value(attribute:, value:)
-          @validated_attributes.delete(attribute.name)
+          validated_attributes.delete(internal.name)
 
           Servactory::Maintenance::Validations::Performer.validate!(
             context: @context,
-            attribute:,
+            attribute: internal,
             value:
           )
 
-          @context.send(:servactory_service_warehouse).assign_internal(attribute.name, value)
+          @context.send(:servactory_service_warehouse).assign_internal(internal.name, value)
 
-          @validated_attributes << attribute.name
+          validated_attributes << internal.name
+        end
+
+        def fetch_with(name:, &_block)
+          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
+
+          internal_name = predicate ? name.to_s.chomp("?").to_sym : name
+          internal = @collection_of_internals.find_by(name: internal_name)
+
+          return yield if internal.nil?
+
+          internal_value = fetch_value(attribute: internal)
+
+          predicate ? Servactory::Utils.query_attribute(internal_value) : internal_value
         end
 
         def fetch_value(attribute:)
           value = @context.send(:servactory_service_warehouse).fetch_internal(attribute.name)
 
-          if @validated_attributes.exclude?(attribute.name)
+          if validated_attributes.exclude?(attribute.name)
             Servactory::Maintenance::Validations::Performer.validate!(
               context: @context,
               attribute:,
@@ -85,8 +86,12 @@ module Servactory
           value
         end
 
-        def fetch_predicate(attribute:)
-          Servactory::Utils.query_attribute(fetch_value(attribute:))
+        def resolve_internal(name)
+          return true if @collection_of_internals.find_by(name:)
+
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_internals.find_by(name: name.to_s.chomp("?").to_sym)
         end
 
         def raise_error_for(type, name)

data/lib/servactory/context/workspace/outputs.rb

@@ -7,8 +7,6 @@ module Servactory
         def initialize(context:, collection_of_outputs:)
           @context = context
           @collection_of_outputs = collection_of_outputs
-
-          define_attribute_methods!
         end
 
         def only(*names)
@@ -23,55 +21,55 @@ module Servactory
             .to_h { |output| [output.name, send(output.name)] }
         end
 
-        def method_missing(name, *_args)
+        def method_missing(name, *args)
           if name.to_s.end_with?("=")
             prepared_name = name.to_s.delete("=").to_sym
-            raise_error_for(:assign, prepared_name)
+
+            assign_with(prepared_name:, value: args.pop) { raise_error_for(:assign, prepared_name) }
           else
-            raise_error_for(:fetch, name)
+            fetch_with(name:) { raise_error_for(:fetch, name) }
           end
         end
 
-        def respond_to_missing?(*)
-          false
+        def respond_to_missing?(name, *)
+          resolve_output(name) || super
         end
 
         private
 
-        def define_attribute_methods! # rubocop:disable Metrics/MethodLength
-          @collection_of_outputs.each do |output|
-            define_singleton_method(output.name) do
-              fetch_value(attribute: output)
-            end
-
-            define_singleton_method(:"#{output.name}=") do |value|
-              assign_value(attribute: output, value:)
-            end
+        def assign_with(prepared_name:, value:, &_block)
+          output = @collection_of_outputs.find_by(name: prepared_name)
 
-            next unless @context.config.predicate_methods_enabled
-
-            define_singleton_method(:"#{output.name}?") do
-              fetch_predicate(attribute: output)
-            end
-          end
-        end
+          return yield if output.nil?
 
-        def assign_value(attribute:, value:)
           Servactory::Maintenance::Validations::Performer.validate!(
             context: @context,
-            attribute:,
+            attribute: output,
             value:
           )
 
-          @context.send(:servactory_service_warehouse).assign_output(attribute.name, value)
+          @context.send(:servactory_service_warehouse).assign_output(output.name, value)
         end
 
-        def fetch_value(attribute:)
-          @context.send(:servactory_service_warehouse).fetch_output(attribute.name)
+        def fetch_with(name:, &_block)
+          predicate = @context.config.predicate_methods_enabled && name.end_with?("?")
+
+          output_name = predicate ? name.to_s.chomp("?").to_sym : name
+          output = @collection_of_outputs.find_by(name: output_name)
+
+          return yield if output.nil?
+
+          output_value = @context.send(:servactory_service_warehouse).fetch_output(output.name)
+
+          predicate ? Servactory::Utils.query_attribute(output_value) : output_value
         end
 
-        def fetch_predicate(attribute:)
-          Servactory::Utils.query_attribute(fetch_value(attribute:))
+        def resolve_output(name)
+          return true if @collection_of_outputs.find_by(name:)
+
+          @context.config.predicate_methods_enabled &&
+            name.to_s.end_with?("?") &&
+            @collection_of_outputs.find_by(name: name.to_s.chomp("?").to_sym)
         end
 
         def raise_error_for(type, name)