trailblazer-endpoint 0.0.5 → 0.0.9

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5856f0724650869732af67c5b45eee354e68a606b97d86153dffa3271adc9ee1
-  data.tar.gz: 01504dc413db4e2dce833908d1687ba0492f157cea3a3bca58853d9615d597d5
+  metadata.gz: 31aba7b848760da16d7c5ad9a7ee24f821acac0b4fd72884e263a5e52468d868
+  data.tar.gz: 71d47c02a27874bbc9e16d64d2844d6d930888b77b653c582e9ebd5d94960f71
 SHA512:
-  metadata.gz: 9c6322150c0dad7b568a77c8dc8b4af4a48c40e6358d18b16cf57e50f3f9515bae3e38a1875f3eb48e420192dbe978a5f7631b5b35f7c1e532e58e52d3f2043a
-  data.tar.gz: 3ff1847a6e2e59fba1d8b3713b7069d58ea7e89be250ab79d5d87b795a5141c6a2c5dd1cc653257191d07906c66c4700fd12408b03200bdc89d87b312451cf96
+  metadata.gz: 24837b2a2fc722d9101b56fe9f35d648f7408574a518bc66fbefcd539ffd4363c44232fb8c51373902782d15986134cecb8d5c811fd504cc6a425ee53d90f8a1
+  data.tar.gz: b25455ecd91f83b3e4bf067b6fbb9e1188d162f894379ec01de91fbb09bff5e38e0517684d1220ef49d7a26a6ab1f477bed554ee8bf407f84950629f7329a435

data/CHANGES.md

@@ -1,3 +1,24 @@
+# 0.0.9
+
+* Fix Ruby 3.0 code.
+* Update dependencies.
+
+# 0.0.8
+
+* Add `Protocol.insert_copy_from_domain_ctx!` to copy from `domain_ctx` to the `endpoint_ctx`.
+
+# 0.0.7
+
+* BREAKING: Remove `:domain_ctx_filter` in favor of `Controller.insert_copy_to_domain_ctx!`.
+* Add support for serializing `:suspend_data` and deserializing `:resume_data` so session data can get automatically encrypted and passed to the next action. This used to sit in `workflow`.
+* Add `:find_process_model`. This introduces a new protocol step before `policy` to find the "process model" instead of letting the domain operation or even the policy (or both!) find the "current model".
+
+# 0.0.6
+
+* `Controller::endpoint` short form introduced.
+* Minor changes for `Controller.module`.
+* Lots of cleanups.
+
 # 0.0.5
 
 * Removed `Protocol::Failure`. Until we have `Railway::End::Failure`, use a normal `Activity::End` everywhere instead of introducing our own.

data/README.md

@@ -1,11 +1,46 @@
 # Trailblazer::Endpoint
 
-*Generic HTTP handlers for operation results.*
+*Endpoints handle authentication, authorization, calling the business logic and response rendering.*
 
-Decouple finding out *what happened* from *what to do*.
+## Overview
 
-t test/controllers/songs_controller_test.rb --backtrace
+An endpoint links your routing with your business code. The idea is that your controllers are pure HTTP routers, calling the respective endpoint for each action. From there, the endpoint takes over, handles authentication, policies, executing the domain code, interpreting the result, and providing hooks to render a response.
 
-## TODO
+Instead of dealing with a mix of `before_filter`s, Rack-middlewares, controller code and callbacks, an endpoint is just another activity and allows to be customized with the well-established Trailblazer mechanics.
 
-* make travis build run `cd test/rails-app/ && rake`
+
+In a Rails controller, a controller action could look as follows.
+
+```ruby
+class DiagramsController < ApplicationController
+  endpoint Diagram::Operation::Create, [:is_logged_in?, :can_add_diagram?]
+
+  def create
+    endpoint Diagram::Operation::Create do |ctx, **|
+      redirect_to diagram_path(ctx[:diagram].id)
+    end.Or do |ctx, **|
+      render :form
+    end
+  end
+end
+```
+
+While routing and redirecting/rendering still happens in Rails, all remaining steps are handled in the endpoint.
+
+An API controller action, where the rendering is done generically, could look much simpler.
+
+```ruby
+class API::V1::DiagramsController < ApplicationController
+  endpoint Diagram::Operation::Create, [:is_logged_in?, :can_add_diagram?]
+
+  def create
+    endpoint Diagram::Operation::Create
+  end
+end
+```
+
+Endpoints are easily customized but their main intent is to reduce fuzzy controller code and providing best practices for both HTML-rendering controllers and APIs.
+
+## Documentation
+
+Read the [full documentation for endpoint](https://trailblazer.to/2.1/docs/endpoint.html) on our website.

data/lib/trailblazer/endpoint/controller.rb

@@ -2,9 +2,9 @@ module Trailblazer
   class Endpoint
     module Controller
       def self.extended(extended)
-        extended.extend Trailblazer::Endpoint::Options::DSL
+        extended.extend Trailblazer::Endpoint::Options::DSL           # ::directive
         extended.extend Trailblazer::Endpoint::Options::DSL::Inherit
-        extended.extend Trailblazer::Endpoint::Options
+        extended.extend Trailblazer::Endpoint::Options                # ::options_for
         extended.extend DSL::Endpoint
 
         extended.include InstanceMethods # {#endpoint_for}
@@ -17,26 +17,41 @@ module Trailblazer
       end
 
       # @experimental
+      # TODO: test application_controller with and without dsl/api
+
       def self.module(framework: :rails, api: false, dsl: false, application_controller: false)
-        if api
+        if application_controller && !api && !dsl # FIXME: not tested! this is useful for an actual AppController with block_options or flow_options settings, "globally"
+          Module.new do
+            def self.included(includer)
+              includer.extend(Controller) # only ::directive and friends.
+            end
+          end
+        elsif api
           Module.new do
+            @application_controller = application_controller
             def self.included(includer)
-              includer.extend(Controller)
-              includer.include(InstanceMethods)
+              if @application_controller
+                includer.extend Controller
+              end
               includer.include(InstanceMethods::API)
             end
           end
-        elsif dsl and !application_controller
+        elsif dsl
           Module.new do
+            @application_controller = application_controller
             def self.included(includer)
-              # includer.extend Trailblazer::Endpoint::Controller
+              if @application_controller
+                includer.extend Controller
+              end
               includer.include Trailblazer::Endpoint::Controller::InstanceMethods::DSL
               includer.include Trailblazer::Endpoint::Controller::Rails
               includer.extend Trailblazer::Endpoint::Controller::Rails::DefaultBlocks
               includer.extend Trailblazer::Endpoint::Controller::Rails::DefaultParams
               includer.include Trailblazer::Endpoint::Controller::Rails::Process
             end
-          end
+          end # Module
+        else
+          raise
         end
       end
 
@@ -77,18 +92,19 @@ module Trailblazer
             extended.directive(:endpoints, ->(*) { {} })
           end
 
-          def endpoint(name, **options, &block)
+          # Builds and registers an endpoint in a controller class.
+          def endpoint(name=nil, **options, &block)
             options = options.merge(protocol_block: block) if block_given?
 
-            return generic_endpoint_config(**name, **options) if name.is_a?(Hash)
-            endpoint_config(name, **options)
+            return generic_endpoint_config(**options) if name.nil?
+
+            build_endpoint(name, **options)
           end
 
-          def generic_endpoint_config(protocol:, adapter:, **options)
+          # Configures generic {:adapter}, {:protocol}, etc.
+          def generic_endpoint_config(**options)
             self.singleton_class.define_method :generic_options do |ctx,**|
               {
-                protocol: protocol,
-                adapter: adapter,
                 **options
               }
             end
@@ -96,13 +112,12 @@ module Trailblazer
             directive :generic_options, method(:generic_options) # FIXME: do we need this?
           end
 
-          def endpoint_config(name, **options)
-            puts "~~~~~~~~~~~~~~~config"
-            build_options = options_for(:generic_options, {}).merge(options) # DISCUSS: why don't we add this as another directive option/step?
+          def build_endpoint(name, domain_activity: name, **options)
+            build_options = options_for(:generic_options, {}).merge(domain_activity: domain_activity, **options) # DISCUSS: why don't we add this as another directive option/step?
 
-            endpoint = Trailblazer::Endpoint.build(build_options)
+            endpoint = Trailblazer::Endpoint.build(**build_options)
 
-            directive :endpoints, ->(*) { {name => endpoint} }
+            directive :endpoints, ->(*) { {name.to_s => endpoint} }
           end
 
         end
@@ -111,15 +126,33 @@ module Trailblazer
       module InstanceMethods
 
         def endpoint_for(name, config_source: self.class)
-          config_source.options_for(:endpoints, {}).fetch(name) # TODO: test non-existant endpoint
+          config_source.options_for(:endpoints, {}).fetch(name.to_s) # TODO: test non-existant endpoint
         end
 
         module DSL
           def endpoint(name, **action_options, &block)
-            action_options = {controller: self}.merge(action_options) # FIXME: redundant with {DSL#endpoint}
+            action_options = {controller: self}.merge(action_options) # FIXME: redundant with {API#endpoint}
 
             endpoint = endpoint_for(name)
 
+            # raise name.inspect unless block_given?
+            # TODO: check {dsl: false}
+            # unless block_given? # FIXME
+            #   config_source = self.class # FIXME
+            #   block_options = config_source.options_for(:options_for_block_options, **action_options)
+            #   block_options = Trailblazer::Endpoint::Options.merge_with(action_options, block_options)
+
+            #   signal, (ctx, _) = Trailblazer::Endpoint::Controller.advance_endpoint_for_controller(
+            #     endpoint:       endpoint,
+            #     block_options:  block_options,
+            #     config_source:  config_source,
+            #     **action_options
+            #   )
+
+            #   return ctx
+            # end
+
+
             invoke_endpoint_with_dsl(endpoint: endpoint, **action_options, &block)
           end
 
@@ -132,7 +165,7 @@ module Trailblazer
           def endpoint(name, config_source: self.class, **action_options)
             endpoint = endpoint_for(name, config_source: config_source)
 
-            action_options = {controller: self}.merge(action_options) # FIXME: redundant with {DSL#endpoint}
+            action_options = {controller: self}.merge(action_options) # FIXME: redundant with {InstanceMethods#endpoint}
 
             block_options = config_source.options_for(:options_for_block_options, **action_options)
             block_options = Trailblazer::Endpoint::Options.merge_with(action_options, block_options)

data/lib/trailblazer/endpoint/dsl.rb

@@ -19,9 +19,11 @@ module Trailblazer
         # #call
         def to_args(default_block_options)
           return options,
+          default_block_options.merge( # this adds :invoke.
             success_block:          success_block || default_block_options[:success_block],
             failure_block:          failure_block || default_block_options[:failure_block],
             protocol_failure_block: protocol_failure_block || default_block_options[:protocol_failure_block]
+          )
         end
       end
     end

data/lib/trailblazer/endpoint/options.rb

@@ -67,29 +67,6 @@ module Trailblazer
         target.instance_variable_set(:@config, config)
       end
 
-      class State < Module
-        def initialize(normalizer, config)
-          @normalizer = normalizer
-          @config = config
-        end
-
-        # called once when extended in {ApplicationController}.
-        def extended(extended)
-          super
-
-          extended.extend(Inherited)
-          Normalizer.add_normalizer!(extended, @normalizer, @config)
-        end
-
-      end
-      module Inherited
-        def inherited(subclass)
-          super
-
-          Normalizer.add_normalizer!(subclass, @normalizer, @config)
-        end
-      end
-
       def self.add(normalizer, directive_name, options)
         Class.new(normalizer) do
           options.collect do |callable|

data/lib/trailblazer/endpoint/protocol/cipher.rb

@@ -0,0 +1,27 @@
+require "openssl"
+
+module Trailblazer
+  class Endpoint::Protocol
+    module Controller
+      module Cipher # FIXME: copied from Tyrant!
+        module_function
+
+        def encrypt_value(ctx, value:, cipher_key:, **)
+          cipher = OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+          cipher.key = Digest::SHA1.hexdigest(cipher_key)[0..23] # ArgumentError: key must be 24 bytes
+          s = cipher.update(value) + cipher.final
+
+          ctx[:encrypted_value] = s.unpack('H*')[0].upcase
+        end
+
+        def decrypt_value(ctx, encrypted_value:, cipher_key:, **)
+          cipher = OpenSSL::Cipher.new('DES-EDE3-CBC').decrypt
+          cipher.key = Digest::SHA1.hexdigest(cipher_key)[0..23]
+          s = [encrypted_value].pack("H*").unpack("C*").pack("c*")
+
+          ctx[:decrypted_value] = cipher.update(s) + cipher.final
+        end
+      end # Cipher
+    end
+  end
+end

data/lib/trailblazer/endpoint/protocol/controller.rb

@@ -0,0 +1,102 @@
+module Trailblazer
+  class Endpoint::Protocol
+    # Deserialize incoming state.
+    # Serialize outgoing state.
+    # What else?
+    module Controller
+      module_function
+
+      def decrypt?(ctx, encrypted_resume_data:, **)
+        encrypted_resume_data
+      end
+
+      def deserialize_resume_data(ctx, decrypted_value:, **)
+        ctx[:resume_data] = JSON.parse(decrypted_value)
+      end
+
+      def deserialize_process_model?(ctx, process_model_from_resume_data:, **)
+        process_model_from_resume_data
+      end
+
+      def deserialize_process_model_id(ctx, resume_data:, **)
+        ctx[:process_model_id] = resume_data["id"] # DISCUSS: overriding {:process_model_id}?
+      end
+
+      def encrypt?(ctx, domain_ctx:, **)
+        ctx[:suspend_data] = domain_ctx[:suspend_data]
+      end
+
+      def serialize_suspend_data(ctx, suspend_data:, **)
+        ctx[:serialized_suspend_data] = JSON.dump(suspend_data)
+      end
+
+      def copy_suspend_data_to_endpoint_ctx(ctx, domain_ctx:, **)
+        ctx[:suspend_data] = domain_ctx[:suspend_data] # FIXME: use {#insert_copy_from_domain_ctx!}
+      end
+
+# FIXME: use Model() mechanics.
+      def deserialize_process_model_id_from_resume_data(ctx, resume_data:, **)
+        # DISCUSS: should we warn when overriding an existing {process_model_id}?
+        ctx[:process_model_id] = resume_data["id"] # DISCUSS: overriding {:process_model_id}? # FIXME: stolen from Advance___::Controller
+      end
+
+      def insert_deserialize_steps!(activity, deserialize_before: :policy)
+        activity.module_eval do
+          step Controller.method(:decrypt?), id: :decrypt?, before: deserialize_before # error out if no serialized_resume_data given.
+          step Controller::Cipher.method(:decrypt_value), id: :decrypt,
+              input: {cipher_key: :cipher_key, encrypted_resume_data: :encrypted_value}    , before: deserialize_before,
+              # Output(:failure) => Track(:success),
+              Output(:success) => Path(connect_to: Track(:success), track_color: :deserialize, before: deserialize_before) do # usually, Path goes into {policy}
+
+            step Controller.method(:deserialize_resume_data), id: :deserialize_resume_data
+            # DISCUSS: unmarshall?
+            # step Controller.method(:deserialize_process_model_id?), id: :deserialize_process_model_id?, activity.Output(Trailblazer::Activity::Left, :failure) => activity.Id(around_activity_id)
+            # step Controller.method(:deserialize_process_model_id), id: :deserialize_process_model_id
+
+            step ->(*) { true } # FIXME: otherwise we can't insert an element AFTER :deserialize_resume_data
+          end
+        end
+      end
+
+      def insert_serialize_steps!(activity, serialize_after: :domain_activity)
+        activity.module_eval do
+            # FIXME: reverse order for insertion
+          step Controller::Cipher.method(:encrypt_value), id: :encrypt                                                , after: serialize_after,
+              input: {cipher_key: :cipher_key, serialized_suspend_data: :value}, output: {encrypted_value: :encrypted_suspend_data}
+          step Controller.method(:serialize_suspend_data), id: :serialize_suspend_data                                , after: serialize_after
+          pass Controller.method(:copy_suspend_data_to_endpoint_ctx), id: :copy_suspend_data_to_endpoint_ctx          , after: serialize_after
+        end
+      end
+
+      # Insert the "experimental" {find_process_model} steps
+      def insert_find_process_model!(protocol, **options)
+        protocol.module_eval do
+          step Subprocess(FindProcessModel), Output(:failure) => End(:not_found),
+          id: :find_process_model,
+          **options
+            # after: :authenticate
+        end
+
+        insert_copy_to_domain_ctx!(protocol, {:process_model => :model})
+      end
+
+      def insert_copy_to_domain_ctx!(protocol, variables, before: :domain_activity) # FIXME: `:before` untested!
+        variables.each do |original_name, domain_name|
+          protocol.module_eval do
+            pass ->(ctx, domain_ctx:, **) { domain_ctx[domain_name] = ctx[original_name] if ctx.key?(original_name) },
+              id: :"copy_[#{original_name.inspect}]_to_domain_ctx[#{domain_name.inspect}]", before: before
+          end
+        end
+      end
+
+      def insert_copy_from_domain_ctx!(protocol, variables, after: :domain_activity) # FIXME: `:after` untested!
+        variables.each do |domain_name, endpoint_name|
+          protocol.module_eval do
+            pass ->(ctx, domain_ctx:, **) { ctx[endpoint_name] = domain_ctx[domain_name] if domain_ctx.key?(domain_name) },
+              id: :"copy_[#{endpoint_name.inspect}]_from_domain_ctx[#{domain_name.inspect}]", after: after
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/endpoint/protocol/find_process_model.rb

@@ -0,0 +1,15 @@
+class Trailblazer::Endpoint::Protocol
+  class FindProcessModel < Trailblazer::Activity::Railway
+    # step :find_process_model?, Output(:failure) => Id("End.success")
+    step :find_process_model#,  Output(:failure) => End(:not_found) # DISCUSS: currently, {End.failure} implies {not_found}.
+
+    # DISCUSS: should the implementation   remain in {Activity}?
+    # def find_process_model?(ctx, find_process_model:, **)
+    #   find_process_model
+    # end
+
+    def find_process_model(ctx, process_model_class:, process_model_id:, **)
+      ctx[:process_model] = process_model_class.find_by(id: process_model_id)
+    end
+  end
+end

data/lib/trailblazer/endpoint/protocol.rb

@@ -24,7 +24,7 @@ module Trailblazer
 
       step :authenticate, Output(:failure) => _Path(semantic: :not_authenticated) do
           # step :handle_not_authenticated
-        end
+      end
 
       step :policy, Output(:failure) => _Path(semantic: :not_authorized) do # user from cookie, etc
         # step :handle_not_authorized
@@ -113,7 +113,6 @@ module Trailblazer
           [[Trailblazer::Activity::TaskWrap::Pipeline.method(:insert_after), "task_wrap.call_task", ["endpoint.end_signal", method(:terminus_handler)]]]
         end
       end
-
-    end
+    end # Protocol
   end
 end

data/lib/trailblazer/endpoint/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Endpoint
-    VERSION = "0.0.5"
+    VERSION = "0.0.9"
   end
 end

data/lib/trailblazer/endpoint.rb

@@ -2,7 +2,12 @@ module Trailblazer
   class Endpoint
     # Create an {Endpoint} class with the provided adapter and protocol.
     # This builder also sets up taskWrap filters around the {domain_activity} execution.
-    def self.build(protocol:, adapter:, domain_activity:, scope_domain_ctx: true, domain_ctx_filter: nil, protocol_block: ->(*) { Hash.new })
+    def self.build(protocol:, adapter:, domain_activity:, scope_domain_ctx: true, protocol_block: ->(*) { Hash.new },
+      serialize: false, # TODO: plug-in, not hardcoded!
+      deserialize: false,# TODO: plug-in, not hardcoded!
+      find_process_model: false, # TODO: plug-in, not hardcoded!
+      deserialize_process_model_id_from_resume_data: false # TODO: plug-in, not hardcoded!
+      )
       # special considerations around the {domain_activity} and its taskWrap:
       #
       #  1. domain_ctx_filter (e.g. to filter {current_user})
@@ -19,14 +24,41 @@ module Trailblazer
       # scoping: {:domain_ctx} becomes ctx
       extensions_options.merge!(Endpoint.options_for_scope_domain_ctx) if scope_domain_ctx # TODO: test flag
 
+      app_protocol = build_protocol(protocol, domain_activity: domain_activity, extensions_options: extensions_options, protocol_block: protocol_block, serialize: serialize, deserialize: deserialize,
+        find_process_model: find_process_model, deserialize_process_model_id_from_resume_data: deserialize_process_model_id_from_resume_data
+        )
+
+      # puts Trailblazer::Developer.render(app_protocol)
+
+      Class.new(adapter) do
+        step(Subprocess(app_protocol), {inherit: true, id: :protocol, replace: :protocol})
+      end # app_adapter
+
+    end
+
+    # @private
+    def self.build_protocol(protocol, domain_activity:, extensions_options:, protocol_block:, serialize:, deserialize:, find_process_model:, deserialize_process_model_id_from_resume_data:)
+      Class.new(protocol) do
+        if serialize
+          Protocol::Controller.insert_serialize_steps!(self)
+        end
+
+        if deserialize
+          Protocol::Controller.insert_deserialize_steps!(self)
+        end
 
-      domain_ctx_filter_callable = [[Trailblazer::Activity::TaskWrap::Pipeline.method(:insert_before), "task_wrap.call_task", ["endpoint.domain_ctx_filter", domain_ctx_filter]]]
-      extensions_options[:extensions] << Trailblazer::Activity::TaskWrap::Extension(merge: domain_ctx_filter_callable) if domain_ctx_filter
+        if serialize || deserialize
+          Protocol::Controller.insert_copy_to_domain_ctx!(self, {:resume_data => :resume_data})
+        end
 
-      # puts Trailblazer::Developer.render(protocol)
-      # puts
+        if find_process_model
+          Protocol::Controller.insert_find_process_model!(self, before: :policy) # TODO: test before: :policy
+        end
+
+        if deserialize_process_model_id_from_resume_data
+          pass Protocol::Controller.method(:deserialize_process_model_id_from_resume_data), after: :deserialize_resume_data, magnetic_to: :deserialize, Output(:success) => Track(:deserialize)
+        end
 
-      app_protocol = Class.new(protocol) do
         step(Subprocess(domain_activity), {inherit: true, id: :domain_activity, replace: :domain_activity,
 
 # FIXME: where does this go?
@@ -35,13 +67,6 @@ module Trailblazer
           merge(instance_exec(&protocol_block)) # the block is evaluated in the {Protocol} context.
         )
       end
-
-      # puts Trailblazer::Developer.render(app_protocol)
-
-      Class.new(adapter) do
-        step(Subprocess(app_protocol), {inherit: true, id: :protocol, replace: :protocol})
-      end # app_adapter
-
     end
 
     def self.options_for_scope_domain_ctx()
@@ -51,19 +76,11 @@ module Trailblazer
       }
     end
 
-    def self.domain_ctx_filter(variables)
-      ->(_ctx, ((ctx, a), b)) do # taskWrap interface
-        variables.each do |variable|
-          ctx[:domain_ctx][variable] = ctx[variable]
-        end
-
-        [_ctx, [[ctx, a], b]]
-      end
-    end
-
     # Runtime
     # Invokes the endpoint for you and runs one of the three outcome blocks.
-    def self.with_or_etc(activity, args, failure_block:, success_block:, protocol_failure_block:, invoke: Trailblazer::Activity::TaskWrap.method(:invoke)) # invoke: Trailblazer::Developer.method(:wtf?)
+    def self.with_or_etc(activity, args, failure_block:, success_block:, protocol_failure_block:, invoke: Trailblazer::Activity::TaskWrap.method(:invoke))
+    # def self.with_or_etc(activity, args, failure_block:, success_block:, protocol_failure_block:, invoke: Trailblazer::Developer.method(:wtf?))
+
       # args[1] = args[1].merge(focus_on: { variables: [:returned], steps: :invoke_workflow })
 
       # signal, (endpoint_ctx, _ ) = Trailblazer::Developer.wtf?(activity, args)
@@ -114,7 +131,7 @@ module Trailblazer
     end
 
     # FIXME: name will change! this is for controllers, only!
-    def self.advance_from_controller(endpoint, success_block:, failure_block:, protocol_failure_block: protocol_failure_block, **argument_options)
+    def self.advance_from_controller(endpoint, success_block:, failure_block:, protocol_failure_block:, **argument_options)
       args = Trailblazer::Endpoint.arguments_for(argument_options)
 
       signal, (ctx, _ ) = Trailblazer::Endpoint.with_or_etc(
@@ -144,3 +161,6 @@ require "trailblazer/endpoint/adapter"
 require "trailblazer/endpoint/dsl"
 require "trailblazer/endpoint/controller"
 require "trailblazer/endpoint/options"
+require "trailblazer/endpoint/protocol/controller"
+require "trailblazer/endpoint/protocol/find_process_model"
+require "trailblazer/endpoint/protocol/cipher"

data/test/docs/controller_test.rb

@@ -58,7 +58,8 @@ class DocsControllerTest < Minitest::Spec
       include T.def_steps(:authenticate, :policy)
     end
 
-    endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web, domain_ctx_filter: Trailblazer::Endpoint.domain_ctx_filter([:current_user, :process_model]), scope_domain_ctx: true
+    endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web,
+    scope_domain_ctx: true
   end
 
   class HtmlController < ApplicationController
@@ -311,4 +312,63 @@ class DocsControllerTest < Minitest::Spec
   end
 end
 
+class ControllerEndpointMethodTest < Minitest::Spec
+# Test {Controller::endpoint}
+
+  class Protocol < Trailblazer::Endpoint::Protocol
+    def policy(*); true; end
+    def authenticate(*); true; end
+  end
+
+  class BasicController
+    include Trailblazer::Endpoint::Controller.module(api: true, application_controller: true)
+
+    directive :options_for_block_options, Trailblazer::Endpoint::Controller.method(:options_for_block_options)
+
+    endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web
+
+    def head(status)
+      @status = status
+    end
+
+    def self.options_for_block_options(ctx, controller:, **)
+      {
+        success_block:          ->(ctx, endpoint_ctx:, **) { controller.head("#{ctx[:op]}") },
+        failure_block:          ->(ctx, status:, **) {  },
+        protocol_failure_block: ->(ctx, status:, **) {  }
+      }
+    end
+
+    directive :options_for_block_options, method(:options_for_block_options)
+  end
+
+  class RodaController < BasicController
+    class Create < Trailblazer::Activity::Railway
+      def save(ctx, **); ctx[:op] = self.class; end;
+      step :save
+    end
+    class Update < Create
+    end
+
+  # {Controller::endpoint}: {:domain_activity} defaults to {name} when not given
+    endpoint Create                           # class {name}s are ok
+    endpoint :update, domain_activity: Update # symbol {name} is ok
+
+    def show
+      endpoint Create
+      @status
+    end
+
+    def update
+      endpoint :update
+      @status
+    end
+  end
+
+
+  it "what" do
+    RodaController.new.show.must_equal %{ControllerEndpointMethodTest::RodaController::Create}
+    RodaController.new.update.must_equal %{ControllerEndpointMethodTest::RodaController::Update}
+  end
+end
 

data/test/rails-app/Gemfile

@@ -13,7 +13,23 @@ gem 'sqlite3', '~> 1.4'
 # Use Rack CORS for handling Cross-Origin Resource Sharing (CORS), making cross-origin AJAX possible
 # gem 'rack-cors'
 
-gem "trailblazer-operation"
+# gem "trailblazer-operation"
+gem "trailblazer-operation", path: "../../../trailblazer-operation"
+gem "trailblazer-context", path: "../../../trailblazer-context"
+gem "trailblazer-activity-dsl-linear", path: "../../../trailblazer-activity-dsl-linear"
+gem "trailblazer-activity", path: "../../../trailblazer-activity"
+
+
 gem "trailblazer-endpoint", path: "../../."
 gem "jwt"
 gem "multi_json"
+gem "minitest-line"
+gem "trailblazer-cells"
+gem "cells-erb"
+gem "cells-rails"
+
+
+# FIXME
+# gem "trailblazer-workflow", path: "../../../trailblazer-workflow"
+# gem "trailblazer-activity-dsl-linear", path: "../../../trailblazer-activity-dsl-linear"
+# gem "trailblazer-activity-dsl-linear", ">= 0.3.4"