typed_operation 1.0.0.beta2 → 1.0.0.pre1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 501477c614c107723d1c915099dd06209336708ba5e9672c26622d02a9cd4782
-  data.tar.gz: b5ab846baf478e3cce3fd8ea1752c04ee708c9a7f84d2be6d47d4c9a94505ac5
+  metadata.gz: ff925e2cc5ce03a696a209e0ca61130bff94ddb6ce28f2670ebaaae18f1968ba
+  data.tar.gz: b14a0952694653f918135a57180c8c7746aeffcb14385d17aeef7a1283726e99
 SHA512:
-  metadata.gz: c3c399b74903b5b9e40ab7838c7d20bafa68969d1200bf2afb11457e41437ae8fa823e7afc14fabe71cd290cd798823f97a0918c4a12d50f6a8768ac1a77ea8e
-  data.tar.gz: b1ce5f67d1b87ef907f00904288b25edd678a2afab0f68a5f2c5804831f5d05df0fad134a4c28a4893d3867f61c671d548bf687f37b822ff32754355845d9abd
+  metadata.gz: 0cb23aed491058bdefba04d75661ec4cb5110a2491ba9d4b3afc929d41e1863a09b9ac09b41bdbd6306856af6d5552f2c86c3057b53df3076d0674a9c1feafda
+  data.tar.gz: 143f6ba5a00d5cabadec3f7f326dc7a724fdd2666ca0dffa326cacf9f9af2f4dce797f77a727468cd919eb42a4b6de530105d6866e49797997c10ff5a36db9fe

data/README.md

@@ -6,12 +6,7 @@ Inputs to the operation are specified as typed attributes (uses [`literal`](http
 
 Type of result of the operation is up to you, eg you could use [`literal` monads](https://github.com/joeldrapper/literal) or [`Dry::Monads`](https://dry-rb.org/gems/dry-monads/1.3/).
 
-**Note the version described here (~ 1.0.0) is pre-release on Rubygems (v1.0.0 is waiting for a release of `literal`). To use it now you can simply require `literal` from github in your Gemfile:**
-
-```ruby
-gem "literal", github: "joeldrapper/literal", branch: "main"
-gem "typed_operation", "~> 1.0.0.beta2"
-```
+**Note the version described here (~ 1.0.0) is not yet released on Rubygems, it is waiting for a release of `literal`)**
 
 ## Features
 
@@ -44,39 +39,26 @@ class ShelveBookOperation < ::TypedOperation::Base
   # Or if you prefer:
   #   `param :description, String`
 
-  # `param` creates named parameters by default
-  param :author_id, Integer, &:to_i
-  param :isbn, String
+  named_param :author_id, Integer, &:to_i
+  named_param :isbn, String
   
   # Optional parameters are specified by wrapping the type constraint in the `optional` method, or using the `optional:` option
-  param :shelf_code, optional(Integer)
+  named_param :shelf_code, optional(Integer)
   # Or if you prefer:
   #   `named_param :shelf_code, Integer, optional: true`
 
-  param :category, String, default: "unknown".freeze
+  named_param :category, String, default: "unknown".freeze
 
-  # optional hook called when the operation is initialized, and after the parameters have been set
+  # to setup (optional)
   def prepare
     raise ArgumentError, "ISBN is invalid" unless valid_isbn?
   end
 
-  # optionally hook in before execution ... and call super to allow subclasses to hook in too
-  def before_execute_operation
-    # ...
-    super
-  end
-
-  # The 'work' of the operation, this is the main body of the operation and must be implemented
-  def perform
+  # The 'work' of the operation
+  def call
     "Put away '#{title}' by author ID #{author_id}#{shelf_code ? " on shelf #{shelf_code}" : "" }"
   end
 
-  # optionally hook in after execution ... and call super to allow subclasses to hook in too
-  def after_execute_operation(result)
-    # ...
-    super
-  end
-  
   private
 
   def valid_isbn?
@@ -110,15 +92,13 @@ shelve.call(author_id: "1", isbn: false)
 
 ### Partially applying parameters
 
-Operations can also be partially applied and curried:
-
 ```ruby
 class TestOperation < ::TypedOperation::Base
   param :foo, String, positional: true
   param :bar, String
   param :baz, String, &:to_s
 
-  def perform = "It worked! (#{foo}, #{bar}, #{baz})"
+  def call = "It worked! (#{foo}, #{bar}, #{baz})"
 end
 
 # Invoking the operation directly
@@ -171,76 +151,21 @@ TestOperation.with("1").with(bar: "2").with(baz: 3).operation
 
 ## Documentation
 
-### Create an operation (subclass `TypedOperation::Base` or `TypedOperation::ImmutableBase`)
-
-Create an operation by subclassing `TypedOperation::Base` or `TypedOperation::ImmutableBase` and specifying the parameters the operation requires.
+### Create an operation (subclass `TypedOperation::Base`)
 
-- `TypedOperation::Base` (uses `Literal::Struct`) is the parent class for an operation where the arguments are potentially mutable (ie not frozen).
-  No attribute writer methods are defined, so the arguments can not be changed after initialization, but the values passed in are not guaranteed to be frozen.
-- `TypedOperation::ImmutableBase` (uses `Literal::Data`) is the parent class for an operation where the arguments are immutable (frozen on initialization),
-  thus giving a somewhat stronger immutability guarantee (ie that the operation does not mutate its arguments).
+Create an operation by subclassing `TypedOperation::Base` and specifying the parameters the operation requires.
 
-The subclass must implement the `#perform` method which is where the operations main work is done.
+The subclass must implement the `#call` method which is where the operations main work is done.
 
 The operation can also implement:
 
 - `#prepare` - called when the operation is initialized, and after the parameters have been set
-- `#before_execute_operation` - optionally hook in before execution ... and call super to allow subclasses to hook in too
-- `#after_execute_operation` - optionally hook in after execution ... and call super to allow subclasses to hook in too
-  
-```ruby
-# optionally hook in before execution...
-def before_execute_operation
-  # Remember to call super
-  super
-end
-
-def perform
-  # ... implement me!
-end
-
-# optionally hook in after execution...
-def after_execute_operation(result)
-  # Remember to call super, note the result is passed in and the return value of this method is the result of the operation
-  # thus allowing you to modify the result if you wish
-  super
-end
-```
 
 ### Specifying parameters (using `.param`)
 
 Parameters are specified using the provided class methods (`.positional_param` and `.named_param`), 
 or using the underlying `.param` method.
 
-Types are specified using the `literal` gem. In many cases this simply means providing the class of the
-expected type, but there are also some other useful types provided by `literal` (eg `Union`).
-
-These can be either accessed via the `Literal` module, eg `Literal::Types::BooleanType`:
-
-```ruby
-class MyOperation < ::TypedOperation::Base
-  param :name, String
-  param :age, Integer, optional: true
-  param :choices, Literal::Types::ArrayType.new(String)
-  param :chose, Literal::Types::BooleanType
-end
-
-MyOperation.new(name: "bob", choices: ["st"], chose: true)
-```
-
-or by including the `Literal::Types` module into your operation class, and using the aliases provided:
-
-```ruby
-class MyOperation < ::TypedOperation::Base
-  include Literal::Types
-  
-  param :name, String
-  param :age, _Nilable(Integer) # optional can also be specifed using `.optional`
-  param :choices, _Array(String)
-  param :chose, _Boolean
-end
-```
-
 Type constraints can be modified to make the parameter optional using `.optional`.
 
 #### Your own aliases
@@ -298,7 +223,7 @@ class MyOperation < ::TypedOperation::Base
   # Or alternatively => `param :name, String, positional: true` 
   positional_param :age, Integer, default: -> { 0 }
   
-  def perform
+  def call
     puts "Hello #{name} (#{age})"
   end
 end
@@ -329,7 +254,7 @@ class MyOperation < ::TypedOperation::Base
   # Or alternatively => `param :name, String` 
   named_param :age, Integer, default: -> { 0 }
   
-  def perform
+  def call
     puts "Hello #{name} (#{age})"
   end
 end
@@ -350,7 +275,7 @@ class MyOperation < ::TypedOperation::Base
   positional_param :name, String
   named_param :age, Integer, default: -> { 0 }
   
-  def perform
+  def call
     puts "Hello #{name} (#{age})"
   end
 end
@@ -394,7 +319,7 @@ You can specify a block after a parameter definition to coerce the argument valu
 
 ```ruby
 param :name, String, &:to_s
-param :choice, Literal::Types::BooleanType do |v|
+param :choice, Union(FalseClass, TrueClass) do |v|
   v == "y"
 end
 ```
@@ -441,10 +366,9 @@ An operation can be invoked by:
 
 - instantiating it with at least required params and then calling the `#call` method on the instance
 - once a partially applied operation has been prepared (all required parameters have been set), the call
-  method on `TypedOperation::Prepared` can be used to instantiate and call the operation.
+  method on TypedOperation::Prepared can be used to instantiate and call the operation.
 - once an operation is curried, the `#call` method on last TypedOperation::Curried in the chain will invoke the operation
 - calling `#call` on a partially applied operation and passing in any remaining required parameters
-- calling `#execute_operation` on an operation instance (this is the method that is called by `#call`)
 
 See the many examples in this document.
 
@@ -522,8 +446,7 @@ This is an example of a `ApplicationOperation` in a Rails app that uses `Dry::Mo
 
 class ApplicationOperation < ::TypedOperation::Base
   # We choose to use dry-monads for our operations, so include the required modules
-  include Dry::Monads[:result]
-  include Dry::Monads::Do.for(:perform)
+  include Dry::Monads[:result, :do]
   
   class << self
     # Setup our own preferred names for the DSL methods
@@ -564,155 +487,41 @@ class ApplicationOperation < ::TypedOperation::Base
 end
 ```
 
-### Using with Action Policy (`action_policy` gem)
-
-> Note, this optional feature requires the `action_policy` gem to be installed and does not yet work with `ImmutableBase`.
-
-Add `TypedOperation::ActionPolicyAuth` to your `ApplicationOperation` (first `require` the module):
-
-```ruby
-require "typed_operation/action_policy_auth"
-
-class ApplicationOperation < ::TypedOperation::Base
-  # ...
-  include TypedOperation::ActionPolicyAuth
-
-  # You can specify a parameter to take the authorization context object, eg a user (can also be optional if some
-  # operations don't require authorization)
-  param :initiator, ::User # or optional(::User)
-end
-```
-
-#### Specify the action with `.action_type`
-
-Every operation must define what action_type it is, eg:
-
-```ruby
-class MyUpdateOperation < ApplicationOperation
-  action_type :update
-end
-```
-
-Any symbol can be used as the `action_type` and this is by default used to determine which policy method to call.
-
-#### Configuring auth with `.authorized_via`
-
-`.authorized_via` is used to specify how to authorize the operation. You must specify the name of a parameter
-for the policy authorization context. You can also specify multiple parameters if you wish.
+### Using with `literal` monads
 
-You can then either provide a block with the logic to perform the authorization check, or provide a policy class.
-
-The `record:` option lets you provide the name of the parameter which will be passed as the policy 'record'.
-
-For example:
+You can use the `literal` gem to provide a `Result` type for your operations.
 
 ```ruby
-class MyUpdateOperation < ApplicationOperation
-  param :initiator, ::AdminUser
-  param :order, ::Order
-  
-  action_type :update
-  
-  authorized_via :initiator, record: :order do
-    # ... the permissions check, admin users can edit orders that are not finalized
-    initiator.admin? && !record.finalized
-  end
-  
-  def perform
-    # ...
-  end
-end
-```
-
-You can instead provide a policy class implementation:
+class MyOperation < ::TypedOperation::Base
+  param :account_name, String
+  param :owner, String
 
-```ruby
-class MyUpdateOperation < ApplicationOperation
-  action_type :update
-  
-  class MyPolicyClass < OperationPolicy
-    # The action_type defined on the operation determines which method is called on the policy class
-    def update?
-      # ... the permissions check
-      initiator.admin?
+  def call
+    create_account.bind do |account|
+      associate_owner(account).bind do
+        account
+      end
     end
-    
-    # def my_check?
-    #   # ... the permissions check
-    # end
   end
-  
-  authorized_via :initiator, with: MyPolicyClass
-  
-  # It is also possible to specify which policy method to call
-  #      authorized_via :initiator, with: MyPolicyClass, to: :my_check?
-end
-```
 
-with multiple parameters:
+  private
 
-```ruby
-class MyUpdateOperation < ApplicationOperation
-  # ...
-  param :initiator, ::AdminUser
-  param :user, ::User
-  
-  authorized_via :initiator, :user do
-    initiator.active? && user.active?
+  def create_account
+    # returns Literal::Success(account) or Literal::Failure(:cant_create)
+    Literal::Success.new(account_name)
   end
   
-  # ...
-end
-```
-
-#### `.verify_authorized!`
-
-To ensure that subclasses always implement authentication you can add a call to `.verify_authorized!` to your base
-operation class.
-
-This will cause the execution of any subclasses to fail if no authorization is performed.
-
-```ruby
-class MustAuthOperation < ApplicationOperation
-  verify_authorized!
-end
-
-class MyUpdateOperation < MustAuthOperation
-  def perform
+  def associate_owner(account)
     # ...
+    Literal::Failure.new(:cant_associate_owner)
   end
 end
 
-MyUpdateOperation.call # => Raises an error that MyUpdateOperation does not perform any authorization
-```
-
-#### `#on_authorization_failure(err)`
+MyOperation.new(account_name: "foo", owner: "bar").call
+# => Literal::Failure(:cant_associate_owner)
 
-A hook is provided to allow you to do some work on an authorization failure.
-
-Simply override the `#on_authorization_failure(err)` method in your operation.
-
-```ruby
-class MyUpdateOperation < ApplicationOperation
-  action_type :update
-  
-  authorized_via :initiator do
-    # ... the permissions check
-    initiator.admin?
-  end
-  
-  def perform
-    # ...
-  end
-  
-  def on_authorization_failure(err)
-    # ... do something with the error, eg logging
-  end
-end
 ```
 
-Note you are provided the ActionPolicy error object, but you cannot stop the error from being re-raised.
-
 ### Using with `Dry::Monads`
 
 As per the example in [`Dry::Monads` documentation](https://dry-rb.org/gems/dry-monads/1.0/do-notation/)
@@ -720,14 +529,14 @@ As per the example in [`Dry::Monads` documentation](https://dry-rb.org/gems/dry-
 ```ruby
 class MyOperation < ::TypedOperation::Base
   include Dry::Monads[:result]
-  include Dry::Monads::Do.for(:perform, :create_account)
+  include Dry::Monads::Do.for(:call)
 
   param :account_name, String
   param :owner, ::Owner
   
-  def perform
+  def call
     account = yield create_account(account_name)
-    yield AnotherOperation.call(account, owner)
+    yield associate_owner(account, owner)
 
     Success(account)
   end
@@ -767,11 +576,8 @@ bin/rails g typed_operation:install
 Use the `--dry_monads` switch to `include Dry::Monads[:result]` into your `ApplicationOperation` (don't forget to also 
 add `gem "dry-monads"` to your Gemfile)
 
-Use the `--action_policy` switch to add the `TypedOperation::ActionPolicyAuth` module to your `ApplicationOperation`
-(and you will also need to add `gem "action_policy"` to your Gemfile).
-
 ```ruby
-bin/rails g typed_operation:install --dry_monads --action_policy
+bin/rails g typed_operation:install --dry_monads
 ```
 
 ## Generate a new Operation

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/setup"
+
+require "bundler/gem_tasks"

data/lib/generators/templates/operation.rb

@@ -14,7 +14,7 @@ module <%= namespace_name %>
       # Prepare...
     end
 
-    def perform
+    def call
       # Perform...
       "Hello World!"
     end
@@ -33,7 +33,7 @@ class <%= name %> < ::ApplicationOperation
     # Prepare...
   end
 
-  def perform
+  def call
     # Perform...
     "Hello World!"
   end

data/lib/generators/typed_operation/install/USAGE

@@ -12,7 +12,6 @@ rails generate typed_operation:install
 Options:
 --------
 --dry_monads: if specified the ApplicationOperation will include dry-monads Result and Do notation.
---action_policy: if specified the ApplicationOperation will include action_policy authorization integration.
 
 Example:
 --------

data/lib/generators/typed_operation/install/install_generator.rb

@@ -6,7 +6,6 @@ module TypedOperation
   module Install
     class InstallGenerator < Rails::Generators::Base
       class_option :dry_monads, type: :boolean, default: false
-      class_option :action_policy, type: :boolean, default: false
 
       source_root File.expand_path("templates", __dir__)
 
@@ -19,10 +18,6 @@ module TypedOperation
       def include_dry_monads?
         options[:dry_monads]
       end
-
-      def include_action_policy?
-        options[:action_policy]
-      end
     end
   end
 end

data/lib/generators/typed_operation/install/templates/application_operation.rb

@@ -1,36 +1,14 @@
 # frozen_string_literal: true
 
 class ApplicationOperation < ::TypedOperation::Base
-<% if include_action_policy? -%>
-  include TypedOperation::ActionPolicyAuth
-
-<% end -%>
 <% if include_dry_monads? -%>
-  include Dry::Monads[:result]
-  include Dry::Monads::Do.for(:perform)
+  include Dry::Monads[:result, :do]
 
-  # Helper to execute then unwrap a successful result or raise an exception
   def call!
     call.value!
   end
 
 <% end -%>
   # Other common parameters & methods for Operations of this application...
-  # Some examples:
-  #
-  #   def self.operation_key
-  #     name.underscore.to_sym
-  #   end
-  #
-  #   def operation_key
-  #     self.class.operation_key
-  #   end
-  #
-  #   # Translation and localization
-  #
-  #   def translate(key, **)
-  #     key = "operations.#{operation_key}.#{key}" if key.start_with?(".")
-  #     I18n.t(key, **)
-  #   end
-  #   alias_method :t, :translate
+  # ...
 end

data/lib/tasks/typed_operation_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :typed_operation do
+#   # Task goes here
+# end

data/lib/typed_operation/attribute_builder.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module TypedOperation
+  class AttributeBuilder
+    def initialize(typed_operation, parameter_name, type_signature, options)
+      @typed_operation = typed_operation
+      @name = parameter_name
+      @signature = type_signature
+      @optional = options[:optional]
+      @positional = options[:positional]
+      @reader = options[:reader] || :public
+      @default_key = options.key?(:default)
+      @default = options[:default]
+
+      prepare_type_signature_for_literal
+    end
+
+    def define(&converter)
+      @typed_operation.attribute(
+        @name,
+        @signature,
+        default: default_value_for_literal,
+        positional: @positional,
+        reader: @reader,
+        &converter
+      )
+    end
+
+    private
+
+    def prepare_type_signature_for_literal
+      @signature = NilableType.new(@signature) if needs_to_be_nilable?
+      union_with_nil_to_support_nil_default
+      validate_positional_order_params! if @positional
+    end
+
+    # If already wrapped in a Nilable then don't wrap again
+    def needs_to_be_nilable?
+      @optional && !type_nilable?
+    end
+
+    def type_nilable?
+      @signature.is_a?(NilableType)
+    end
+
+    def union_with_nil_to_support_nil_default
+      @signature = Literal::Union.new(@signature, NilClass) if has_default_value_nil?
+    end
+
+    def has_default_value_nil?
+      default_provided? && @default.nil?
+    end
+
+    def validate_positional_order_params!
+      # Optional ones can always be added after required ones, or before any others, but required ones must be first
+      unless type_nilable? || @typed_operation.optional_positional_parameters.empty?
+        raise ParameterError, "Cannot define required positional parameter '#{@name}' after optional positional parameters"
+      end
+    end
+
+    def default_provided?
+      @default_key
+    end
+
+    def default_value_for_literal
+      if has_default_value_nil? || type_nilable?
+        -> {}
+      else
+        @default
+      end
+    end
+  end
+end

data/lib/typed_operation/base.rb

@@ -1,13 +1,106 @@
 # frozen_string_literal: true
 
+require "literal"
+
 module TypedOperation
-  class Base < Literal::Struct
-    extend Operations::Introspection
-    extend Operations::Parameters
-    extend Operations::PartialApplication
-
-    include Operations::Lifecycle
-    include Operations::Callable
-    include Operations::Executable
+  class Base < Literal::Data
+    class << self
+      def call(...)
+        new(...).call
+      end
+
+      def with(...)
+        PartiallyApplied.new(self, ...).with
+      end
+      alias_method :[], :with
+
+      def curry
+        Curried.new(self)
+      end
+
+      def to_proc
+        method(:call).to_proc
+      end
+
+      # Method to define parameters for your operation.
+
+      # Parameter for keyword argument, or a positional argument if you use positional: true
+      # Required, but you can set a default or use optional: true if you want optional
+      def param(name, signature = :any, **options, &converter)
+        AttributeBuilder.new(self, name, signature, options).define(&converter)
+      end
+
+      # Alternative DSL
+
+      # Parameter for positional argument
+      def positional_param(name, signature = :any, **options, &converter)
+        param(name, signature, **options.merge(positional: true), &converter)
+      end
+
+      # Parameter for a keyword or named argument
+      def named_param(name, signature = :any, **options, &converter)
+        param(name, signature, **options.merge(positional: false), &converter)
+      end
+
+      # Wrap a type signature in a NilableType meaning it is optional to TypedOperation
+      def optional(type_signature)
+        NilableType.new(type_signature)
+      end
+
+      # Introspection methods
+
+      def positional_parameters
+        literal_attributes.filter_map { |name, attribute| name if attribute.positional? }
+      end
+
+      def keyword_parameters
+        literal_attributes.filter_map { |name, attribute| name unless attribute.positional? }
+      end
+
+      def required_positional_parameters
+        required_parameters.filter_map { |name, attribute| name if attribute.positional? }
+      end
+
+      def required_keyword_parameters
+        required_parameters.filter_map { |name, attribute| name unless attribute.positional? }
+      end
+
+      def optional_positional_parameters
+        positional_parameters - required_positional_parameters
+      end
+
+      def optional_keyword_parameters
+        keyword_parameters - required_keyword_parameters
+      end
+
+      private
+
+      def required_parameters
+        literal_attributes.filter do |name, attribute|
+          attribute.default.nil? # Any optional parameters will have a default value/proc in their Literal::Attribute
+        end
+      end
+    end
+
+    def after_initialization
+      prepare if respond_to?(:prepare)
+    end
+
+    def call
+      raise InvalidOperationError, "You must implement #call"
+    end
+
+    def to_proc
+      method(:call).to_proc
+    end
+
+    def deconstruct
+      attributes.values
+    end
+
+    def deconstruct_keys(keys)
+      h = attributes.to_h
+      keys ? h.slice(*keys) : h
+    end
   end
 end

data/lib/typed_operation/nilable_type.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require "literal"
+
+module TypedOperation
+  class NilableType < Literal::Union
+    def initialize(*types)
+      @types = types + [NilClass]
+    end
+  end
+end

data/lib/typed_operation/version.rb

@@ -1,3 +1,3 @@
 module TypedOperation
-  VERSION = "1.0.0.beta2"
+  VERSION = "1.0.0.pre1"
 end

data/lib/typed_operation.rb

@@ -2,19 +2,11 @@ if Gem::Version.new(RUBY_VERSION) < Gem::Version.new("3.2.0")
   require "polyfill-data"
 end
 
-require "literal"
-
 require "typed_operation/version"
 require "typed_operation/railtie" if defined?(Rails::Railtie)
-require "typed_operation/operations/introspection"
-require "typed_operation/operations/parameters"
-require "typed_operation/operations/partial_application"
-require "typed_operation/operations/callable"
-require "typed_operation/operations/lifecycle"
-require "typed_operation/operations/property_builder"
-require "typed_operation/operations/executable"
+require "typed_operation/nilable_type"
+require "typed_operation/attribute_builder"
 require "typed_operation/curried"
-require "typed_operation/immutable_base"
 require "typed_operation/base"
 require "typed_operation/partially_applied"
 require "typed_operation/prepared"

metadata

@@ -1,17 +1,17 @@
 --- !ruby/object:Gem::Specification
 name: typed_operation
 version: !ruby/object:Gem::Version
-  version: 1.0.0.beta2
+  version: 1.0.0.pre1
 platform: ruby
 authors:
 - Stephen Ierodiaconou
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-06-24 00:00:00.000000000 Z
+date: 2023-08-20 00:00:00.000000000 Z
 dependencies: []
-description: Command pattern, which is callable, and can be partially applied, curried
-  and has typed parameters. Authorization to execute via action_policy if desired.
+description: TypedOperation is a command pattern implementation where inputs can be
+  defined with runtime type checks. Operations can be partially applied.
 email:
 - stevegeek@gmail.com
 executables: []
@@ -20,6 +20,7 @@ extra_rdoc_files: []
 files:
 - MIT-LICENSE
 - README.md
+- Rakefile
 - lib/generators/USAGE
 - lib/generators/templates/operation.rb
 - lib/generators/templates/operation_test.rb
@@ -27,18 +28,12 @@ files:
 - lib/generators/typed_operation/install/install_generator.rb
 - lib/generators/typed_operation/install/templates/application_operation.rb
 - lib/generators/typed_operation_generator.rb
+- lib/tasks/typed_operation_tasks.rake
 - lib/typed_operation.rb
-- lib/typed_operation/action_policy_auth.rb
+- lib/typed_operation/attribute_builder.rb
 - lib/typed_operation/base.rb
 - lib/typed_operation/curried.rb
-- lib/typed_operation/immutable_base.rb
-- lib/typed_operation/operations/callable.rb
-- lib/typed_operation/operations/executable.rb
-- lib/typed_operation/operations/introspection.rb
-- lib/typed_operation/operations/lifecycle.rb
-- lib/typed_operation/operations/parameters.rb
-- lib/typed_operation/operations/partial_application.rb
-- lib/typed_operation/operations/property_builder.rb
+- lib/typed_operation/nilable_type.rb
 - lib/typed_operation/partially_applied.rb
 - lib/typed_operation/prepared.rb
 - lib/typed_operation/railtie.rb
@@ -57,16 +52,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: '3.2'
+      version: '3.1'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
-  - - ">="
+  - - ">"
     - !ruby/object:Gem::Version
-      version: '0'
+      version: 1.3.1
 requirements: []
-rubygems_version: 3.5.3
+rubygems_version: 3.4.18
 signing_key:
 specification_version: 4
-summary: TypedOperation is a command pattern with typed parameters, which is callable,
-  and can be partially applied.
+summary: TypedOperation is a command pattern implementation
 test_files: []

data/lib/typed_operation/action_policy_auth.rb

@@ -1,141 +0,0 @@
-# frozen_string_literal: true
-
-require "action_policy"
-
-# An optional module to include in your operation to enable authorization via ActionPolicies
-module TypedOperation
-  class MissingAuthentication < StandardError; end
-
-  module ActionPolicyAuth
-    # Base class for any action policy classes used by operations
-    class OperationPolicy
-      include ActionPolicy::Policy::Core
-      include ActionPolicy::Policy::Authorization
-      include ActionPolicy::Policy::PreCheck
-      include ActionPolicy::Policy::Reasons
-      include ActionPolicy::Policy::Aliases
-      include ActionPolicy::Policy::Scoping
-      include ActionPolicy::Policy::Cache
-      include ActionPolicy::Policy::CachedApply
-    end
-
-    def self.included(base)
-      base.include ::ActionPolicy::Behaviour
-      base.extend ClassMethods
-    end
-
-    module ClassMethods
-      # Configure the operation to use ActionPolicy for authorization
-      def authorized_via(*via, with: nil, to: nil, record: nil, &auth_block)
-        # If a block is provided, you must not provide a policy class or method
-        raise ArgumentError, "You must not provide a policy class or method when using a block" if auth_block && (with || to)
-
-        parameters = positional_parameters + keyword_parameters
-        raise ArgumentError, "authorize_via must be called with a valid param name" unless via.all? { |param| parameters.include?(param) }
-        @_authorized_via_param = via
-
-        action_type_method = "#{action_type}?".to_sym if action_type
-        # If an method name is provided, use it
-        policy_method = to || action_type_method || raise(::TypedOperation::InvalidOperationError, "You must provide an action type or policy method name")
-        @_policy_method = policy_method
-        # If a policy class is provided, use it
-        @_policy_class = if with
-          with
-        elsif auth_block
-          policy_class = Class.new(OperationPolicy) do
-            authorize(*via)
-
-            define_method(policy_method, &auth_block)
-          end
-          const_set(:Policy, policy_class)
-          policy_class
-        else
-          raise ::TypedOperation::InvalidOperationError, "You must provide either a policy class or a block"
-        end
-
-        if record
-          unless parameters.include?(record) || method_defined?(record) || private_instance_methods.include?(record)
-            raise ArgumentError, "to_authorize must be called with a valid param or method name"
-          end
-          @_to_authorize_param = record
-        end
-
-        # Configure action policy to use the param named in via as the context when instantiating the policy
-        # ::ActionPolicy::Behaviour does not provide a authorize(*ids) method, so we have call once per param
-        via.each do |param|
-          authorize param
-        end
-      end
-
-      def action_type(type = nil)
-        @_action_type = type.to_sym if type
-        @_action_type
-      end
-
-      def operation_policy_method
-        @_policy_method
-      end
-
-      def operation_policy_class
-        @_policy_class
-      end
-
-      def operation_record_to_authorize
-        @_to_authorize_param
-      end
-
-      def checks_authorization?
-        !(@_authorized_via_param.nil? || @_authorized_via_param.empty?)
-      end
-
-      # You can use this on an operation base class to ensure and subclasses always enable authorization
-      def verify_authorized!
-        return if verify_authorized?
-        @_verify_authorized = true
-      end
-
-      def verify_authorized?
-        @_verify_authorized
-      end
-
-      def inherited(subclass)
-        super
-        subclass.instance_variable_set(:@_authorized_via_param, @_authorized_via_param)
-        subclass.instance_variable_set(:@_verify_authorized, @_verify_authorized)
-        subclass.instance_variable_set(:@_policy_class, @_policy_class)
-        subclass.instance_variable_set(:@_policy_method, @_policy_method)
-        subclass.instance_variable_set(:@_action_type, @_action_type)
-      end
-    end
-
-    private
-
-    # Redefine it as private
-    def execute_operation
-      if self.class.verify_authorized? && !self.class.checks_authorization?
-        raise ::TypedOperation::MissingAuthentication, "Operation #{self.class.name} must authorize. Remember to use `.authorize_via`"
-      end
-      operation_check_authorized! if self.class.checks_authorization?
-      super
-    end
-
-    def operation_check_authorized!
-      policy = self.class.operation_policy_class
-      raise "No Action Policy policy class provided, or no #{self.class.name}::Policy found for this action" unless policy
-      policy_method = self.class.operation_policy_method
-      raise "No policy method provided or action_type not set for #{self.class.name}" unless policy_method
-      # Record to authorize, if nil then action policy tries to work it out implicitly
-      record_to_authorize = send(self.class.operation_record_to_authorize) if self.class.operation_record_to_authorize
-
-      authorize! record_to_authorize, to: policy_method, with: policy
-    rescue ::ActionPolicy::Unauthorized => e
-      on_authorization_failure(e)
-      raise e
-    end
-
-    # A hook for subclasses to override to do something on an authorization failure
-    def on_authorization_failure(authorization_error)
-      # noop
-    end
-  end
-end

data/lib/typed_operation/immutable_base.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-module TypedOperation
-  class ImmutableBase < Literal::Data
-    extend Operations::Introspection
-    extend Operations::Parameters
-    extend Operations::PartialApplication
-
-    include Operations::Lifecycle
-    include Operations::Callable
-    include Operations::Executable
-  end
-end

data/lib/typed_operation/operations/callable.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-module TypedOperation
-  module Operations
-    module Callable
-      def self.included(base)
-        base.extend(CallableMethods)
-      end
-
-      module CallableMethods
-        def call(...)
-          new(...).call
-        end
-
-        def to_proc
-          method(:call).to_proc
-        end
-      end
-
-      include CallableMethods
-    end
-  end
-end

data/lib/typed_operation/operations/executable.rb

@@ -1,29 +0,0 @@
-# frozen_string_literal: true
-
-module TypedOperation
-  module Operations
-    module Executable
-      def call
-        execute_operation
-      end
-
-      def execute_operation
-        before_execute_operation
-        retval = perform
-        after_execute_operation(retval)
-      end
-
-      def before_execute_operation
-        # noop
-      end
-
-      def after_execute_operation(retval)
-        retval
-      end
-
-      def perform
-        raise InvalidOperationError, "Operation #{self.class} does not implement #perform"
-      end
-    end
-  end
-end

data/lib/typed_operation/operations/introspection.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module TypedOperation
-  module Operations
-    # Introspection methods
-    module Introspection
-      def positional_parameters
-        literal_properties.filter_map { |property| property.name if property.positional? }
-      end
-
-      def keyword_parameters
-        literal_properties.filter_map { |property| property.name if property.keyword? }
-      end
-
-      def required_parameters
-        literal_properties.filter { |property| property.required? }
-      end
-
-      def required_positional_parameters
-        required_parameters.filter_map { |property| property.name if property.positional? }
-      end
-
-      def required_keyword_parameters
-        required_parameters.filter_map { |property| property.name if property.keyword? }
-      end
-
-      def optional_positional_parameters
-        positional_parameters - required_positional_parameters
-      end
-
-      def optional_keyword_parameters
-        keyword_parameters - required_keyword_parameters
-      end
-    end
-  end
-end

data/lib/typed_operation/operations/lifecycle.rb

@@ -1,12 +0,0 @@
-# frozen_string_literal: true
-
-module TypedOperation
-  module Operations
-    module Lifecycle
-      # This is called by Literal on initialization of underlying Struct/Data
-      def after_initialize
-        prepare if respond_to?(:prepare)
-      end
-    end
-  end
-end

data/lib/typed_operation/operations/parameters.rb

@@ -1,36 +0,0 @@
-# frozen_string_literal: true
-
-module TypedOperation
-  module Operations
-    # Method to define parameters for your operation.
-    module Parameters
-      # Override literal `prop` to prevent creating writers (Literal::Data does this by default)
-      def self.prop(name, type, kind = :keyword, reader: :public, writer: :public, default: nil)
-        super(name, type, kind, reader:, writer: false, default:)
-      end
-
-      # Parameter for keyword argument, or a positional argument if you use positional: true
-      # Required, but you can set a default or use optional: true if you want optional
-      def param(name, signature = :any, **options, &converter)
-        PropertyBuilder.new(self, name, signature, options).define(&converter)
-      end
-
-      # Alternative DSL
-
-      # Parameter for positional argument
-      def positional_param(name, signature = :any, **options, &converter)
-        param(name, signature, **options.merge(positional: true), &converter)
-      end
-
-      # Parameter for a keyword or named argument
-      def named_param(name, signature = :any, **options, &converter)
-        param(name, signature, **options.merge(positional: false), &converter)
-      end
-
-      # Wrap a type signature in a NilableType meaning it is optional to TypedOperation
-      def optional(type_signature)
-        Literal::Types::NilableType.new(type_signature)
-      end
-    end
-  end
-end

data/lib/typed_operation/operations/partial_application.rb

@@ -1,16 +0,0 @@
-# frozen_string_literal: true
-
-module TypedOperation
-  module Operations
-    module PartialApplication
-      def with(...)
-        PartiallyApplied.new(self, ...).with
-      end
-      alias_method :[], :with
-
-      def curry
-        Curried.new(self)
-      end
-    end
-  end
-end

data/lib/typed_operation/operations/property_builder.rb

@@ -1,81 +0,0 @@
-# frozen_string_literal: true
-
-module TypedOperation
-  module Operations
-    class PropertyBuilder
-      def initialize(typed_operation, parameter_name, type_signature, options)
-        @typed_operation = typed_operation
-        @name = parameter_name
-        @signature = type_signature
-        @optional = options[:optional] # Wraps signature in NilableType
-        @positional = options[:positional] # Changes kind to positional
-        @reader = options[:reader] || :public
-        @default_key = options.key?(:default)
-        @default = options[:default]
-
-        prepare_type_signature_for_literal
-      end
-
-      def define(&converter)
-        # If nilable, then converter should not attempt to call the type converter block if the value is nil
-        coerce_by = if type_nilable? && converter
-          ->(v) { (v == Literal::Null || v.nil?) ? v : converter.call(v) }
-        else
-          converter
-        end
-        @typed_operation.prop(
-          @name,
-          @signature,
-          @positional ? :positional : :keyword,
-          default: default_value_for_literal,
-          reader: @reader,
-          &coerce_by
-        )
-      end
-
-      private
-
-      def prepare_type_signature_for_literal
-        @signature = Literal::Types::NilableType.new(@signature) if needs_to_be_nilable?
-        union_with_nil_to_support_nil_default
-        validate_positional_order_params! if @positional
-      end
-
-      # If already wrapped in a Nilable then don't wrap again
-      def needs_to_be_nilable?
-        @optional && !type_nilable?
-      end
-
-      def type_nilable?
-        @signature.is_a?(Literal::Types::NilableType)
-      end
-
-      def union_with_nil_to_support_nil_default
-        @signature = Literal::Types::UnionType.new(@signature, NilClass) if has_default_value_nil?
-      end
-
-      def has_default_value_nil?
-        default_provided? && @default.nil?
-      end
-
-      def validate_positional_order_params!
-        # Optional ones can always be added after required ones, or before any others, but required ones must be first
-        unless type_nilable? || @typed_operation.optional_positional_parameters.empty?
-          raise ParameterError, "Cannot define required positional parameter '#{@name}' after optional positional parameters"
-        end
-      end
-
-      def default_provided?
-        @default_key
-      end
-
-      def default_value_for_literal
-        if has_default_value_nil? || type_nilable?
-          -> {}
-        else
-          @default
-        end
-      end
-    end
-  end
-end