interaktor 0.2.0 → 0.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: be48f704b8d52c81c07e9708d1e90230ead270e4da3ddf74e8e4e6251e677978
-  data.tar.gz: '09e99c6f8129b44ff287aa9e8a742327cac3a232f13d7596ece9b428a575bc28'
+  metadata.gz: 750eeac422a483d0c47ed00a3e457e97c43a134e611962f3a2316335d5c1a942
+  data.tar.gz: 6fb7f28d30d78c6dcca2ea25383bdb85576e83600d7de3cad58a13ffa5e14b94
 SHA512:
-  metadata.gz: ea1fe86854da930c537f9fb69864accdf8cb1948d8dacae4b64685ff88508964e99eb968826a12e5653791f492c1e8af6426b734838c5ac152c581dfee6399ba
-  data.tar.gz: 0d8c4406b6d3ee81f39c6adc56118ce4e204465743eed6dc5f342f3b3b5a9a03722f9b04ed48dab265ef9bfbcb54e047476245fdf000295b150e2a835f8087e6
+  metadata.gz: 239222c9b5d7633b6c011d9e14ff1ec65f9612a3e1f13709ce8326c35bef28455b84f749a063927bb97e5387b8fd561019b3ead8ce681c7efc23c523736c777c
+  data.tar.gz: aaf8d1f62d5e86fbfa079ad2c3222d920eb3119999c7a4dc3809cb32799abe7bc8102db7bb431d3cf07f27cc06f9ef38abce9e22955396464440ccb61b9d6634

data/.github/workflows/publish.yml

@@ -2,7 +2,6 @@ name: Publish
 
 on:
   push:
-    branches: [master]
     tags:
       - v*
 

data/.github/workflows/tests.yml

@@ -7,10 +7,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu, macos]
-        ruby: [2.5, 2.6, 2.7, head, debug]
-    runs-on: ${{ matrix.os }}-latest
+        os: [ubuntu-latest, macos-latest]
+        ruby: [2.5, 2.6, 2.7, 3.0, head, debug]
+    runs-on: ${{ matrix.os }}
     continue-on-error: ${{ endsWith(matrix.ruby, 'head') || matrix.ruby == 'debug' }}
+    env:
+      BUNDLE_GEMFILE: "Gemfile.ci"
     steps:
       - uses: actions/checkout@v2
       - name: Set up Ruby
@@ -18,7 +20,5 @@ jobs:
         with:
           ruby-version: ${{ matrix.ruby }}
           bundler-cache: true
-      - name: Install dependencies
-        run: bundle install
       - name: Run tests
         run: bundle exec rspec

data/.gitignore

@@ -4,6 +4,7 @@
 .config
 .yardoc
 Gemfile.lock
+Gemfile.ci.lock
 InstalledFiles
 _yardoc
 coverage
@@ -15,3 +16,5 @@ spec/reports
 test/tmp
 test/version_tmp
 tmp
+spec/examples.txt
+/vendor

data/Gemfile

@@ -2,12 +2,12 @@ source "https://rubygems.org"
 
 gemspec
 
+gem "guard-rspec", require: false
 gem "rubocop"
 gem "rubocop-performance"
 gem "rubocop-rspec"
 gem "rufo", "~> 0.12.0"
 gem "solargraph"
-gem "guard-rspec", require: false
 
 group :test do
   gem "pry-byebug", platforms: [:mri]

data/Gemfile.ci

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+gemspec
+
+gem "rspec", "~> 3.9.0"
+gem "simplecov"

data/README.md

@@ -5,11 +5,11 @@
 
 **DISCLAIMER: Interaktor is under active development. Feel free to use it, but until 1.0 is released, any update could break compatibility with an older version.**
 
-**Interaktor** is a fork of [Interaktor by collectiveidea](https://github.com/collectiveidea/interaktor). While Interactor is still used by collectiveidea internally, communication and progress has been slow in adapting to pull requests and issues. This inactivity combined with my desire to dial back on the Interactor's inherent permissivity led me to fork it and create Interaktor.
+**Interaktor** is a fork of [Interactor by collectiveidea](https://github.com/collectiveidea/interactor). While Interactor is still used by collectiveidea internally, communication and progress has been slow in adapting to pull requests and issues. This inactivity combined with my desire to dial back on the Interactor's inherent permissivity led me to fork it and create Interaktor.
 
 Fundamentally, Interaktor is the same as Interactor, but with the following changes:
 
-- Required explicit definition of interaktor "attributes" which replaces the concept of the interaktor context. Attributes can be required or optional, and support options like default values.
+- Required explicit definition of interaktor "attributes" which replaces the concept of the interaktor context. Attributes are defined using a schema DSL provided by [dry-schema](https://github.com/dry-rb/dry-schema), which allows for complex validation, if desired.
 - The interaktor "context" is no longer a public-facing concept, all data/attribute accessors/setters are defined as attributes
 - Attributes passed to `#fail!` must be defined in advance
 - Interaktors support early-exit functionality through the use of `#success!`, which functions the same as `#fail!` in that you must define the required success attributes on the interaktor
@@ -34,15 +34,18 @@ Interaktors are used to encapsulate your application's [business logic](http://e
 
 Depending on its definition, an interaktor may require attributes to be passed in when it is invoked. These attributes contain everything the interaktor needs to do its work.
 
-You may define `required` or `optional` attributes.
+Attributes are defined using a schema DSL provided by the [dry-schema](https://github.com/dry-rb/dry-schema) gem. It allows the construction of schemas for validating attributes. The schema is typically provided as a block argument to the `input` class method as seen below.
+
+This example is an extremely simple case, and dry-schema supports highly complex schema validation, like type checking, nested hash data validation, and more. For more information on defining an attribute schema, please see the [dry-schema documentation website](https://dry-rb.org/gems/dry-schema). This link should take you to the latest version of dry-schema, but be sure to check that the version of dry-schema in your application bundle matches the documentation you are viewing.
 
 ```ruby
 class CreateUser
   include Interaktor
 
-  required :name
-
-  optional :email
+  input do
+    required(:name)
+    optional(:email)
+  end
 
   def call
     User.create!(
@@ -53,9 +56,12 @@ class CreateUser
 end
 
 CreateUser.call(name: "Foo Bar")
-
 ```
 
+`input` will also accept a `Dry::Schema::Params` object directly, if for some reason the schema needs to be constructed elsewhere.
+
+**A note about type checking**: Type checking is cool, but Ruby is a dynamic language, and Ruby developers tend to utilize the idea of [duck typing](https://en.wikipedia.org/wiki/Duck_typing). Forcing the attributes of an interaktor to be of a certain type in order to validate might sound like a good idea, but it can often cause problems in situations where you might like to use duck typing, for example, when using stubs in tests.
+
 #### Output attributes
 
 Based on the outcome of the interaktor's work, we can require certain attributes. In the example below, we must succeed with a `user_id` attribute, and if we fail, we must provide an `error_messages` attribute.
@@ -66,11 +72,17 @@ The use of `#success!` allows you to early-return from an interaktor's work. If
 class CreateUser
   include Interaktor
 
-  required :name
+  input do
+    required(:name).filled(:string)
+  end
 
-  success :user_id
+  success do
+    required(:user_id).value(:integer)
+  end
 
-  failure :error_messages
+  failure do
+    required(:error_messages).value(array[:string])
+  end
 
   def call
     user = User.new(name: name)
@@ -98,7 +110,7 @@ end
 
 Normally, however, these exceptions are not seen. In the recommended usage, the caller invokes the interaktor using the class method `.call`, then checks the `#success?` method of the returned object. This works because the `call` class method swallows exceptions. When unit testing an interaktor, if calling custom business logic methods directly and bypassing `call`, be aware that `fail!` will generate such exceptions.
 
-See _Interaktors in the controller_, below, for the recommended usage of `call` and `success?`.
+See _Interaktors in the controller_, below, for the recommended usage of `.call` and `#success?`.
 
 ### Hooks
 
@@ -235,13 +247,19 @@ A basic interaktor is a class that includes `Interaktor` and defines `call`.
 class AuthenticateUser
   include Interaktor
 
-  required :email
-  required :password
+  input do
+    required(:email).filled(:string)
+    required(:password).filled(:string)
+  end
 
-  success :user
-  success :token
+  success do
+    required(:user)
+    required(:token).filled(:string)
+  end
 
-  failure :message
+  failure do
+    required(:message).filled(:string)
+  end
 
   def call
     if user = User.authenticate(email, password)
@@ -263,7 +281,9 @@ An organizer is an important variation on the basic interaktor. Its single purpo
 class PlaceOrder
   include Interaktor::Organizer
 
-  required :order_params
+  input do
+    required(:order_params).filled(:hash)
+  end
 
   organize CreateOrder, ChargeCard, SendThankYou
 end
@@ -304,9 +324,13 @@ In addition, any interaktors that had already run are given the chance to undo t
 class CreateOrder
   include Interaktor
 
-  required :order_params
+  input do
+    required(:order_params).filled(:hash)
+  end
 
-  success :order
+  success do
+    required(:order)
+  end
 
   def call
     order = Order.create(order_params)
@@ -334,13 +358,19 @@ When written correctly, an interaktor is easy to test because it only _does_ one
 class AuthenticateUser
   include Interaktor
 
-  required :email
-  required :password
+  input do
+    required(:email).filled(:string)
+    required(:password).filled(:string)
+  end
 
-  success :user
-  success :token
+  success do
+    required(:user)
+    required(:token).filled(:string)
+  end
 
-  failure :message
+  failure do
+    required(:message).filled(:string)
+  end
 
   def call
     if user = User.authenticate(email, password)
@@ -406,12 +436,18 @@ It's a good idea to define your own interfaces to your models. Doing so makes it
 class AuthenticateUser
   include Interaktor
 
-  required :email
-  required :password
+  input do
+    required(:email).filled(:string)
+    required(:password).filled(:string)
+  end
 
-  success :user
+  success do
+    required(:user)
+  end
 
-  failure :message
+  failure do
+    required(:message).filled(:string)
+  end
 
   def call
     user = User.find_by(email: email)
@@ -515,4 +551,4 @@ This controller test will have to change very little during the life of the appl
 
 ### Rails
 
-Interactor provided [interactor-rails](https://github.com/collectiveidea/interactor-rails), which ensures `app/interactors` is included in your autoload paths, and provides generators for new interactors. I have no intention of maintaining generators but if someone feels strongly enough to submit a pull request to include the functionality in _this_ gem (not a separate Rails one) then I will be happy to take a look. Making sure `app/interactors` is included in your autoload paths is something I would like to do soon.
+Interactor provided [interactor-rails](https://github.com/collectiveidea/interactor-rails), which ensures `app/interactors` is included in your autoload paths, and provides generators for new interactors. I have no intention of maintaining generators but if someone feels strongly enough to submit a pull request to include the functionality in _this_ gem (not a separate Rails one) then I will be happy to take a look. Making sure `app/interaktors` is included in your autoload paths is something I would like to do soon.

data/interaktor.gemspec

@@ -1,9 +1,9 @@
 Gem::Specification.new do |spec|
   spec.name = "interaktor"
-  spec.version = "0.2.0"
+  spec.version = "0.3.0"
 
   spec.author = "Taylor Thurlow"
-  spec.email = "taylorthurlow@me.com"
+  spec.email = "thurlow@hey.com"
   spec.description = "A common interface for building service objects."
   spec.summary = "Simple service object implementation"
   spec.homepage = "https://github.com/taylorthurlow/interaktor"
@@ -13,6 +13,7 @@ Gem::Specification.new do |spec|
   spec.required_ruby_version = ">= 2.5"
   spec.require_path = "lib"
 
+  spec.add_runtime_dependency "dry-schema", "~> 1.0"
   spec.add_runtime_dependency "zeitwerk", "~> 2.0"
 
   spec.add_development_dependency "rake", "~> 13.0"

data/lib/interaktor.rb

@@ -32,11 +32,11 @@ module Interaktor
   #
   # @return [void]
   def fail!(failure_attributes = {})
-    # Make sure we have all required attributes
-    missing_attrs = self.class
-                        .failure_attributes
-                        .reject { |failure_attr| failure_attributes.key?(failure_attr) }
-    raise Interaktor::Error::MissingAttributeError.new(self.class.to_s, missing_attrs) if missing_attrs.any?
+    # Silently remove any attributes that are not included in the schema
+    allowed_keys = self.class.failure_schema.key_map.keys.map { |k| k.name.to_sym }
+    failure_attributes.select! { |k, _| allowed_keys.include?(k.to_sym) }
+
+    self.class.validate_failure_schema(failure_attributes)
 
     @context.fail!(failure_attributes)
   end
@@ -48,16 +48,11 @@ module Interaktor
   #
   # @return [void]
   def success!(success_attributes = {})
-    # Make sure we have all required attributes
-    missing_attrs = self.class
-                        .success_attributes
-                        .reject { |success_attr| success_attributes.key?(success_attr) }
-    raise Interaktor::Error::MissingAttributeError.new(self.class.to_s, missing_attrs) if missing_attrs.any?
+    # Silently remove any attributes that are not included in the schema
+    allowed_keys = self.class.success_schema.key_map.keys.map { |k| k.name.to_sym }
+    success_attributes.select! { |k, _| allowed_keys.include?(k.to_sym) }
 
-    # Make sure we haven't provided any unknown attributes
-    unknown_attrs = success_attributes.keys
-                                      .reject { |success_attr| self.class.success_attributes.include?(success_attr) }
-    raise Interaktor::Error::UnknownAttributeError.new(self.class.to_s, unknown_attrs) if unknown_attrs.any?
+    self.class.validate_success_schema(success_attributes)
 
     @context.success!(success_attributes)
   end
@@ -104,8 +99,8 @@ module Interaktor
         call
       end
 
-      if !@context.early_return? && self.class.success_attributes.any?
-        raise Interaktor::Error::MissingAttributeError.new(self, self.class.success_attributes)
+      if !@context.early_return? && self.class.required_success_attributes.any?
+        raise Interaktor::Error::MissingExplicitSuccessError.new(self, self.class.required_success_attributes)
       end
 
       @context.called!(self)

data/lib/interaktor/callable.rb

@@ -1,3 +1,7 @@
+require "dry-schema"
+
+Dry::Schema.load_extensions(:info)
+
 module Interaktor::Callable
   # When the module is included in a class, add the relevant class methods to
   # that class.
@@ -8,131 +12,277 @@ module Interaktor::Callable
   end
 
   module ClassMethods
+    ####################
+    # INPUT ATTRIBUTES #
+    ####################
+
     # The list of attributes which are required to be passed in when calling
     # the interaktor.
     #
     # @return [Array<Symbol>]
-    def required_attributes
-      @required_attributes ||= []
+    def required_input_attributes
+      @required_input_attributes ||= input_schema.info[:keys]
+                                                 .select { |_, info| info[:required] }
+                                                 .keys
     end
 
-    # The list of attributes which are NOT required to be passed in when
+    # The list of attributes which are not required to be passed in when
     # calling the interaktor.
     #
     # @return [Array<Symbol>]
-    def optional_attributes
-      @optional_attributes ||= []
+    def optional_input_attributes
+      # Adding an optional attribute with NO predicates with Dry::Schema is
+      # sort of a "nothing statement" - the schema can sort of ignore it. The
+      # problem is that the optional-with-no-predicate key is not included in
+      # the #info results, so we need to find an list of keys elsewhere, find
+      # the ones that are listed there but not in the #info results, and find
+      # the difference. The result are the keys that are omitted from the #info
+      # result because they are optional and have no predicates.
+      #
+      # See https://github.com/dry-rb/dry-schema/issues/347
+      @optional_input_attributes ||= begin
+          attributes_in_info = input_schema.info[:keys].keys
+          all_attributes = input_schema.key_map.keys.map(&:id)
+          optional_attributes_by_exclusion = all_attributes - attributes_in_info
+
+          explicitly_optional_attributes = input_schema.info[:keys].reject { |_, info| info[:required] }.keys
+
+          explicitly_optional_attributes + optional_attributes_by_exclusion
+        end
     end
 
-    # A list of optional attributes and their default values.
+    # The complete list of input attributes.
     #
     # @return [Array<Symbol>]
-    def optional_defaults
-      @optional_defaults ||= {}
+    def input_attributes
+      required_input_attributes + optional_input_attributes
     end
 
-    # A list of attributes which could be passed when calling the interaktor.
+    # Get the input attribute schema. Fall back to an empty schema with a
+    # configuration that will deny ALL provided attributes - not defining an
+    # input schema should mean the interaktor has no input attributes.
     #
-    # @return [Array<Symbol>]
-    def input_attributes
-      required_attributes + optional_attributes
+    # @return [Dry::Schema::Params]
+    def input_schema
+      @input_schema || Dry::Schema.Params
     end
 
-    # The list of attributes which are required to be passed in when calling
-    # `#fail!` from within the interaktor.
+    # @param context [Hash]
     #
-    # @return [Array<Symbol>]
-    def failure_attributes
-      @failure_attributes ||= []
+    # @return [void]
+    def validate_input_schema(context)
+      return unless input_schema
+
+      result = input_schema.call(context)
+
+      if result.errors.any?
+        raise Interaktor::Error::AttributeSchemaValidationError.new(
+          self,
+          result.errors.to_h,
+        )
+      end
     end
 
-    # The list of attributes which are required to be passed in when calling
-    # `#fail!` from within the interaktor.
+    # @param schema [Dry::Schema::Params, nil] a predefined schema object
+    # @yield a new Dry::Schema::Params definition block
+    def input(schema = nil, &block)
+      raise "No schema or schema definition block provided to interaktor input." if schema.nil? && !block
+
+      raise "Provided both a schema and a schema definition block for interaktor input." if schema && block
+
+      if schema
+        raise "Provided argument is not a Dry::Schema::Params object." unless schema.is_a?(Dry::Schema::Params)
+
+        @input_schema = schema
+      elsif block
+        @input_schema = Dry::Schema.Params { instance_eval(&block) }
+      end
+
+      # define the getters and setters for the input attributes
+      @input_schema.key_map.keys.each do |key| # rubocop:disable Style/HashEachMethods
+        attribute_name = key.id
+
+        # Define getter
+        define_method(attribute_name) { @context.send(attribute_name) }
+
+        # Define setter
+        define_method("#{attribute_name}=".to_sym) do |value|
+          @context.send("#{attribute_name}=".to_sym, value)
+        end
+      end
+    end
+
+    ######################
+    # FAILURE ATTRIBUTES #
+    ######################
+
+    # The list of attributes which are required to be provided when failing the
+    # interaktor.
     #
     # @return [Array<Symbol>]
-    def success_attributes
-      @success_attributes ||= []
+    def required_failure_attributes
+      @required_failure_attributes ||= failure_schema.info[:keys]
+        .select { |_, info| info[:required] }
+        .keys
     end
 
-    # A DSL method for documenting required interaktor attributes.
-    #
-    # @param attributes [Symbol, Array<Symbol>] the list of attribute names
-    # @param options [Hash]
+    # The list of attributes which are not required to be provided when failing
+    # the interaktor.
     #
-    # @return [void]
-    def required(*attributes, **options)
-      required_attributes.concat attributes
+    # @return [Array<Symbol>]
+    def optional_failure_attributes
+      # Adding an optional attribute with NO predicates with Dry::Schema is
+      # sort of a "nothing statement" - the schema can sort of ignore it. The
+      # problem is that the optional-with-no-predicate key is not included in
+      # the #info results, so we need to find an list of keys elsewhere, find
+      # the ones that are listed there but not in the #info results, and find
+      # the difference. The result are the keys that are omitted from the #info
+      # result because they are optional and have no predicates.
+      #
+      # See https://github.com/dry-rb/dry-schema/issues/347
+      @optional_failure_attributes ||= begin
+          attributes_in_info = failure_schema.info[:keys].keys
+          all_attributes = failure_schema.key_map.keys.map(&:id)
+          optional_attributes_by_exclusion = all_attributes - attributes_in_info
 
-      attributes.each do |attribute|
-        # Define getter
-        define_method(attribute) { @context.send(attribute) }
+          explicitly_optional_attributes = failure_schema.info[:keys].reject { |_, info| info[:required] }.keys
 
-        # Define setter
-        define_method("#{attribute}=".to_sym) do |value|
-          @context.send("#{attribute}=".to_sym, value)
+          explicitly_optional_attributes + optional_attributes_by_exclusion
         end
+    end
 
-        raise Interaktor::Error::UnknownOptionError.new(self.class.to_s, options) if options.any?
-      end
+    # The complete list of failure attributes.
+    #
+    # @return [Array<Symbol>]
+    def failure_attributes
+      required_failure_attributes + optional_failure_attributes
     end
 
-    # A DSL method for documenting optional interaktor attributes.
+    # Get the failure attribute schema. Fall back to an empty schema with a
+    # configuration that will deny ALL provided attributes - not defining an
+    # failure schema should mean the interaktor has no failure attributes.
     #
-    # @param attributes [Symbol, Array<Symbol>] the list of attribute names
-    # @param options [Hash]
+    # @return [Dry::Schema::Params]
+    def failure_schema
+      @failure_schema || Dry::Schema.Params
+    end
+
+    # @param context [Hash]
     #
     # @return [void]
-    def optional(*attributes, **options)
-      optional_attributes.concat attributes
+    def validate_failure_schema(context)
+      return unless failure_schema
 
-      attributes.each do |attribute|
-        # Define getter
-        define_method(attribute) { @context.send(attribute) }
+      result = failure_schema.call(context)
 
-        # Define setter
-        define_method("#{attribute}=".to_sym) do |value|
-          unless @context.to_h.key?(attribute)
-            raise Interaktor::Error::DisallowedAttributeAssignmentError.new(self.class.to_s, [attribute])
-          end
+      if result.errors.any?
+        raise Interaktor::Error::AttributeSchemaValidationError.new(
+          self,
+          result.errors.to_h,
+        )
+      end
+    end
 
-          @context.send("#{attribute}=".to_sym, value)
-        end
+    # @param schema [Dry::Schema::Params, nil] a predefined schema object
+    # @yield a new Dry::Schema::Params definition block
+    def failure(schema = nil, &block)
+      raise "No schema or schema definition block provided to interaktor failure method." if schema.nil? && !block
 
-        # Handle options
-        optional_defaults[attribute] = options[:default] if options[:default]
-        options.delete(:default)
+      raise "Provided both a schema and a schema definition block for interaktor failure method." if schema && block
 
-        raise Interaktor::Error::UnknownOptionError.new(self.class.to_s, options) if options.any?
+      if schema
+        raise "Provided argument is not a Dry::Schema::Params object." unless schema.is_a?(Dry::Schema::Params)
+
+        @failure_schema = schema
+      elsif block
+        @failure_schema = Dry::Schema.Params { instance_eval(&block) }
       end
     end
 
-    # A DSL method for documenting required interaktor failure attributes.
+    ######################
+    # SUCCESS ATTRIBUTES #
+    ######################
+
+    # The list of attributes which are required to be provided when the
+    # interaktor succeeds.
     #
-    # @param attributes [Symbol, Array<Symbol>] the list of attribute names
-    # @param options [Hash]
+    # @return [Array<Symbol>]
+    def required_success_attributes
+      @required_success_attributes ||= success_schema.info[:keys]
+                                                     .select { |_, info| info[:required] }
+                                                     .keys
+    end
+
+    # The list of attributes which are not required to be provided when failing
+    # the interaktor.
     #
-    # @return [void]
-    def failure(*attributes, **options)
-      failure_attributes.concat attributes
+    # @return [Array<Symbol>]
+    def optional_success_attributes
+      # Adding an optional attribute with NO predicates with Dry::Schema is
+      # sort of a "nothing statement" - the schema can sort of ignore it. The
+      # problem is that the optional-with-no-predicate key is not included in
+      # the #info results, so we need to find an list of keys elsewhere, find
+      # the ones that are listed there but not in the #info results, and find
+      # the difference. The result are the keys that are omitted from the #info
+      # result because they are optional and have no predicates.
+      #
+      # See https://github.com/dry-rb/dry-schema/issues/347
+      @optional_success_attributes ||= begin
+          attributes_in_info = success_schema.info[:keys].keys
+          all_attributes = success_schema.key_map.keys.map(&:id)
+          optional_attributes_by_exclusion = all_attributes - attributes_in_info
 
-      attributes.each do |attribute|
-        # Handle options
-        raise Interaktor::Error::UnknownOptionError.new(self.class.to_s, options) if options.any?
-      end
+          explicitly_optional_attributes = success_schema.info[:keys].reject { |_, info| info[:required] }.keys
+
+          explicitly_optional_attributes + optional_attributes_by_exclusion
+        end
     end
 
-    # A DSL method for documenting required interaktor success attributes.
+    # The complete list of success attributes.
     #
-    # @param attributes [Symbol, Array<Symbol>] the list of attribute names
-    # @param options [Hash]
+    # @return [Array<Symbol>]
+    def success_attributes
+      required_success_attributes + optional_success_attributes
+    end
+
+    # Get the success attribute schema. Fall back to an empty schema with a
+    # configuration that will deny ALL provided attributes - not defining an
+    # success schema should mean the interaktor has no success attributes.
+    #
+    # @return [Dry::Schema::Params]
+    def success_schema
+      @success_schema || Dry::Schema.Params
+    end
+
+    # @param context [Hash]
     #
     # @return [void]
-    def success(*attributes, **options)
-      success_attributes.concat attributes
+    def validate_success_schema(context)
+      return unless success_schema
+
+      result = success_schema.call(context)
 
-      attributes.each do |attribute|
-        # Handle options
-        raise Interaktor::Error::UnknownOptionError.new(self.class.to_s, options) if options.any?
+      if result.errors.any?
+        raise Interaktor::Error::AttributeSchemaValidationError.new(
+          self,
+          result.errors.to_h,
+        )
+      end
+    end
+
+    # @param schema [Dry::Schema::Params, nil] a predefined schema object
+    # @yield a new Dry::Schema::Params definition block
+    def success(schema = nil, &block)
+      raise "No schema or schema definition block provided to interaktor success method." if schema.nil? && !block
+
+      raise "Provided both a schema and a schema definition block for interaktor success method." if schema && block
+
+      if schema
+        raise "Provided argument is not a Dry::Schema::Params object." unless schema.is_a?(Dry::Schema::Params)
+
+        @success_schema = schema
+      elsif block
+        @success_schema = Dry::Schema.Params { instance_eval(&block) }
       end
     end
 
@@ -174,45 +324,22 @@ module Interaktor::Callable
     #
     # @return [Interaktor::Context] the context, following interaktor execution
     def execute(context, raise_exception)
-      unless context.is_a?(Hash) || context.is_a?(Interaktor::Context)
-        raise ArgumentError, "Expected a hash argument when calling the interaktor, got a #{context.class} instead."
-      end
-
-      apply_default_optional_attributes(context)
-      verify_attribute_presence(context)
-
       run_method = raise_exception ? :run! : :run
 
-      new(context).tap(&run_method).instance_variable_get(:@context)
-    end
-
-    # Check the provided context against the attributes defined with the DSL
-    # methods, and determine if there are any attributes which are required and
-    # have not been provided, or if there are any attributes which have been
-    # provided but are not listed as either required or optional.
-    #
-    # @param context [Interaktor::Context] the context to check
-    #
-    # @return [void]
-    def verify_attribute_presence(context)
-      # TODO: Add "allow_nil?" option to required attributes
-      missing_attrs = required_attributes.reject { |required_attr| context.to_h.key?(required_attr) }
-      raise Interaktor::Error::MissingAttributeError.new(self, missing_attrs) if missing_attrs.any?
+      case context
+      when Hash
+        # Silently remove any attributes that are not included in the schema
+        allowed_keys = input_schema.key_map.keys.map { |k| k.name.to_sym }
+        context.select! { |k, _| allowed_keys.include?(k.to_sym) }
 
-      allowed_attrs = required_attributes + optional_attributes
-      extra_attrs = context.to_h.keys.reject { |attr| allowed_attrs.include?(attr) }
-      raise Interaktor::Error::UnknownAttributeError.new(self, extra_attrs) if extra_attrs.any?
-    end
+        validate_input_schema(context)
 
-    # Given the list of optional default attribute values defined by the class,
-    # assign those default values to the context if they were omitted.
-    #
-    # @param context [Interaktor::Context]
-    #
-    # @return [void]
-    def apply_default_optional_attributes(context)
-      optional_defaults.each do |attribute, default|
-        context[attribute] ||= default
+        new(context).tap(&run_method).instance_variable_get(:@context)
+      when Interaktor::Context
+        new(context).tap(&run_method).instance_variable_get(:@context)
+      else
+        raise ArgumentError,
+              "Expected a hash argument when calling the interaktor, got a #{context.class} instead."
       end
     end
   end