Module: Teckel::Operation

Defined in:

lib/teckel/operation.rb,
lib/teckel/operation/results.rb

Overview

The main operation Mixin

Each operation is expected to declare input. output and error classes.

There are two ways of declaring those classes. The first way is to define the constants Input, Output and Error, the second way is to use the input. output and error methods to point them to anonymous classes.

If you like “traditional” result objects (to ask successful? or failure? on) see Teckel::Operation::Results

Examples:

class definitions via constants

class CreateUserViaConstants
  include Teckel::Operation

  class Input
    def initialize(name:, age:)
      @name, @age = name, age
    end
    attr_reader :name, :age
  end

  Output = ::User

  class Error
    def initialize(message, errors)
      @message, @errors = message, errors
    end
    attr_reader :message, :errors
  end

  input_constructor :new
  error_constructor :new

  # @param [CreateUser::Input]
  # @return [User | CreateUser::Error]
  def call(input)
    user = ::User.new(name: input.name, age: input.age)
    if user.safe
      user
    else
      fail!(message: "Could not safe User", errors: user.errors)
    end
  end
end

CreateUserViaConstants.call(name: "Bob", age: 23).is_a?(User) #=> true

class definitions via methods

class CreateUserViaMethods
  include Teckel::Operation

  input  Types::Hash.schema(name: Types::String, age: Types::Coercible::Integer)
  output Types.Instance(User)
  error  Types::Hash.schema(message: Types::String, errors: Types::Array.of(Types::Hash))

  # @param [Hash<name: String, age: Integer>]
  # @return [User | Hash<message: String, errors: [Hash]>]
  def call(input)
    user = User.new(name: input[:name], age: input[:age])
    if user.safe
      # exits early with success, prevents any further execution
      success!(user)
    else
      fail!(message: "Could not safe User", errors: user.errors)
    end
  end
end

# A success call:
CreateUserViaMethods.call(name: "Bob", age: 23).is_a?(User) #=> true

# A failure call:
CreateUserViaMethods.call(name: "Bob", age: 10).eql?(message: "Could not safe User", errors: [{age: "underage"}]) #=> true

# Build your Input, Output and Error classes in a way that let you know:
begin; CreateUserViaMethods.call(unwanted: "input"); rescue => e; e end.is_a?(::Dry::Types::MissingKeyError) #=> true

# Feed an instance of the input class directly to call:
CreateUserViaMethods.call(CreateUserViaMethods.input[name: "Bob", age: 23]).is_a?(User) #=> true

See Also:

• Results

Defined Under Namespace

Modules: ClassMethods, InstanceMethods, Results

Class Method Summary

• .included(receiver) ⇒ Object

Class Method Details

.included(receiver) ⇒ Object

# File 'lib/teckel/operation.rb', line 320

def self.included(receiver)
  receiver.extend         ClassMethods
  receiver.send :include, InstanceMethods

  receiver.class_eval do
    @config = Config.new

    @input_class = nil
    @input_constructor = nil

    @output_class = nil
    @output_constructor = nil

    @error_class = nil
    @error_constructor = nil

    protected :success!, :fail!
  end
end