trailblazer-endpoint 0.0.3 → 0.0.8

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/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Endpoint
-    VERSION = "0.0.3"
+    VERSION = "0.0.8"
   end
 end

data/test/adapter/api_test.rb

@@ -12,14 +12,13 @@ class AdapterAPITest < Minitest::Spec
         protocol: protocol, # do we cover all usual routes?
         adapter:  Trailblazer::Endpoint::Adapter::API,
         scope_domain_ctx: false,
-    ) do
-
-
-      {Output(:not_found) => Track(:not_found)}
-    end
+        protocol_block: -> { {Output(:not_found) => Track(:not_found)} }
+    )
 
   # success
     assert_route endpoint, {}, :authenticate, :policy, :model, :validate, :success, status: 200
+  # created, when passing 201
+    assert_route endpoint, {success_status: 201}, :authenticate, :policy, :model, :validate, :success, status: 201
   # authentication error
     assert_route endpoint, {authenticate: false}, :authenticate, :fail_fast, status: 401           # fail_fast == protocol error
   # policy error
@@ -47,12 +46,8 @@ class AdapterAPITest < Minitest::Spec
         protocol: protocol, # do we cover all usual routes?
         adapter: adapter,
         scope_domain_ctx: false,
-
-    ) do
-
-
-      {Output(:not_found) => Track(:not_found)}
-    end
+        protocol_block: -> { {Output(:not_found) => Track(:not_found)} }
+    )
 
     class TestErrors < Struct.new(:message)
       def ==(b)

data/test/adapter/web_test.rb

@@ -19,11 +19,8 @@ class AdapterWebTest < Minitest::Spec
         protocol: protocol, # do we cover all usual routes?
         adapter:  Trailblazer::Endpoint::Adapter::Web,
         scope_domain_ctx: false,
-    ) do
-
-
-      {Output(:not_found) => Track(:not_found)}
-    end
+        protocol_block: -> { {Output(:not_found) => Track(:not_found)} }
+    )
 
   # success
     assert_route(endpoint, {}, :authenticate, :policy, :model, :validate, :success)

data/test/config_test.rb

@@ -17,12 +17,22 @@ class ConfigTest < Minitest::Spec
     ApeBabeController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true}}
     ApeBabeController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:current_user=>\"Yo\"}}
 
+    # 4t-h level, also inherit everything from 2-nd level
+    ApeBabeKidController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true}}
+    ApeBabeKidController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:current_user=>\"Yo\"}}
+
     BoringController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true, :xml=>"<XML"}}
     BoringController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:policy=>\"Ehm\"}}
 
     OverridingController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:redis=>\"Arrr\"}}
   end
 
+  it "raises helpful exception with unknown directive" do
+    assert_raises KeyError do
+      ApplicationController.options_for(:unknown_options, {})
+    end
+  end
+
   class ApplicationController
     def self.options_for_endpoint(ctx, **)
       {
@@ -58,6 +68,10 @@ class ConfigTest < Minitest::Spec
     # directive :options_for_domain_ctx, method(:options_for_domain_ctx)
   end
 
+  class ApeBabeKidController < ApeController
+
+  end
+
   class BoringController < ApplicationController
     def self.options_for_domain_ctx(ctx, **) {policy: "Ehm",} end
     def self.options_for_endpoint(ctx, **)   {xml: "<XML",} end
@@ -101,3 +115,14 @@ class RuntimeOptionsTest < Minitest::Spec
     ApplicationController.options_for(:options_for_endpoint, controller: {params: {id: 1}}).inspect.must_equal %{{:option=>nil, :params=>{:id=>1}, :my_params=>\"{:id=>1}\"}}
   end
 end
+
+class OptionsTest < Minitest::Spec
+  # Options#merge_with
+  it "works with empty {merged}" do
+    Trailblazer::Endpoint::Options.merge_with({}, {a: 1, b: 2}).inspect.must_equal %{{:a=>1, :b=>2}}
+  end
+
+  it "keys in merged have precedence, but unknown {merged} keys are discarded" do
+    Trailblazer::Endpoint::Options.merge_with({a: 3, d: 4}, {a: 1, b: 2}).inspect.must_equal %{{:a=>3, :b=>2}}
+  end
+end

data/test/docs/controller_test.rb

@@ -1,11 +1,11 @@
 require "test_helper"
 
 class DocsControllerTest < Minitest::Spec
-
   class ApplicationController
-    def self.options_for_endpoint(ctx, **)
+    def self.options_for_endpoint(ctx, controller:, **)
       {
         find_process_model: true,
+        **controller.instance_variable_get(:@params)[:params],
       }
     end
 
@@ -15,30 +15,53 @@ class DocsControllerTest < Minitest::Spec
       }
     end
 
+    def self.options_for_flow_options(ctx, **)
+      {
+      }
+    end
+
+    def self.options_for_block_options(ctx, controller:, **)
+      {
+        success_block:          ->(ctx, seq:, **) { controller.instance_exec { render seq << :success_block } },
+        failure_block:          ->(ctx, seq:, **) { controller.instance_exec { render seq << :failure_block } },
+        protocol_failure_block: ->(ctx, seq:, **) { controller.instance_exec { render seq << :protocol_failure_block } }
+      }
+    end
+
+
     extend Trailblazer::Endpoint::Controller
+
+    # include Trailblazer::Endpoint::Controller::InstanceMethods      # {#endpoint_for}
+    include Trailblazer::Endpoint::Controller::InstanceMethods::DSL # {#endpoint}
+
+    include Trailblazer::Endpoint::Controller::Rails
+    include Trailblazer::Endpoint::Controller::Rails::Process
+
     directive :options_for_endpoint, method(:options_for_endpoint), method(:request_options)
+    directive :options_for_flow_options, method(:options_for_flow_options)
+    directive :options_for_block_options, method(:options_for_block_options)
 
-    def process(action_name, params:)
+    def process(action_name, **params)
       @params = params
-      send(action_name)
+      send_action(action_name)
+      @render
     end
 
     def render(text)
       @render = text
     end
-  end
 
-  class ApeController < ApplicationController
-    def self.options_for_domain_ctx(ctx, **)
-      {
-        current_user: "Yo",
-      }
+
+
+
+    Protocol = Class.new(Trailblazer::Endpoint::Protocol) do
+      include T.def_steps(:authenticate, :policy)
     end
 
-    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+    endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web,
+    scope_domain_ctx: true
   end
 
-
   class HtmlController < ApplicationController
     private def endpoint_for(*)
       protocol = Class.new(Trailblazer::Endpoint::Protocol) do
@@ -50,46 +73,31 @@ class DocsControllerTest < Minitest::Spec
           domain_activity: Minitest::Spec.new(nil).activity, # FIXME
           protocol: protocol,
           adapter: Trailblazer::Endpoint::Adapter::Web,
-          scope_domain_ctx: false,
+          scope_domain_ctx: true,
 
       ) do
         {Output(:not_found) => Track(:not_found)}
       end
     end
 
-    private def advance_endpoint(options, &block)
-      endpoint = endpoint_for(options)
-
-      ctx = Trailblazer::Endpoint.advance_from_controller(
-
-        endpoint,
-
-        # retrieve/compute options_for_domain_ctx and options_for_endpoint
-
-        domain_ctx: {seq: seq=[], current_user: "Yo", **@params},
-        flow_options: {},
-
-        **options,
-
-        seq: seq,
+    def self.options_for_domain_ctx(ctx, seq:, controller:, **)
+      {
         current_user: "Yo",
-        **@params,
-      )
+        seq: seq,
+        **controller.instance_variable_get(:@params)[:params],
+      }
     end
 
-    private def _endpoint(action, params: {}, &block)
-      success_block =          ->(ctx, seq:, **) { render seq << :success_block }
-      failure_block =          ->(ctx, seq:, **) { render seq << :failure_block }
-      protocol_failure_block = ->(ctx, seq:, **) { render seq << :protocol_failure_block }
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
 
-      dsl = Trailblazer::Endpoint::DSL::Runtime.new({action: action, params: params}, block || success_block, failure_block, protocol_failure_block) # provides #Or etc, is returned to {Controller#call}
+    private def _endpoint(action, seq: [], &block)
+      endpoint(action, seq: seq, &block)
     end
 
     # all standard routes are user-defined
     def view
       _endpoint "view?" do |ctx, seq:, **|
         render "success" + ctx[:current_user] + seq.inspect
-
       end.failure do |ctx, seq:, **|
         render "failure" + ctx[:current_user] + seq.inspect
 
@@ -114,16 +122,6 @@ class DocsControllerTest < Minitest::Spec
       end
     end
 
-    def process(*)
-      dsl = super
-
-      options, block_options = dsl.to_args
-
-      advance_endpoint(**options, **block_options)
-
-      @render
-    end
-
   end # HtmlController
 
   it "what" do
@@ -171,57 +169,206 @@ class DocsControllerTest < Minitest::Spec
     # from controller-default
     controller.process(:update, params: {authenticate: false}).must_equal [:authenticate, :protocol_failure_block]
   end
-end
 
-class ControllerOptionsTest < Minitest::Spec
-  class Controller
-    include Trailblazer::Endpoint::Controller
 
-    def view
-      endpoint "view?"
+# Test if {domain_ctx} is automatically wrapped via Context() so that we can use string-keys.
+# TODO: test if aliases etc are properly passed.
+  class OptionsController < HtmlController
+    def self.options_for_domain_ctx(ctx, seq:, controller:, **)
+      {
+        "contract.params" => Object, # string-key should usually break if not wrapped
+      }
     end
 
-    # we add {:options_for_domain_ctx} manually
-    def download
-      endpoint "download?", params: {id: params[:other_id]}, redis: "Redis"
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        current_user: "Yogi",
+        process_model: Class,
+      }
     end
 
-    # override some settings from {endpoint_options}:
-    def new
-      endpoint "new?", find_process_model: false
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+    directive :options_for_endpoint, method(:options_for_endpoint), inherit: false
+
+    def view
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx["contract.params"].to_s + seq.inspect
+      end
     end
+  end # OptionsController
+
+  it "allows string keys in {domain_ctx} since it gets automatically Ctx()-wrapped" do
+    controller = OptionsController.new
+    controller.process(:view, params: {}).must_equal %{successObject[:authenticate, :policy, :model, :validate]}
   end
 
-  class ControllerThatDoesntInherit
-    include Trailblazer::Endpoint::Controller
 
-    def options_for_domain_ctx
+# copy from {endpoint_ctx} to {domain_ctx}
+  class DomainContextController < ApplicationController
+    private def _endpoint(action, seq: [], **options, &block)
+      endpoint(action, seq: seq, **options, &block)
+    end
+
+    Activity = Class.new(Trailblazer::Activity::Railway) do
+      step :check
+
+      def check(ctx, current_user:, seq:, process_model:, **)
+        seq << :check
+        ctx[:message] = "#{current_user} / #{process_model}"
+      end
+    end
+
+    endpoint "view?", domain_activity: Activity
+    endpoint "show?", domain_activity: Activity
+
+
+    def self.options_for_domain_ctx(ctx, seq:, controller:, **)
+      {
+        seq: seq,
+      }
+    end
+
+    def self.options_for_endpoint(ctx, controller:, **)
       {
-        params: params
+        current_user: "Yogi",
+        process_model: Class,
+        something: true,
       }
     end
 
-    def options_for_endpoint
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+    directive :options_for_endpoint, method(:options_for_endpoint), inherit: false
+
+    def view
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx[:message].to_s + seq.inspect
+      end
+    end
+
+    def show
+      # override existing domain_ctx
+      # make options here available in steps
+      _endpoint "show?", options_for_domain_ctx: {params: {id: 1}, seq: []} do |ctx, seq:, params:, **|
+        render "success" + ctx[:message].to_s + seq.inspect + params.inspect
+      end
+    end
 
+    def create
+      # add endpoint_options
+      _endpoint "show?", policy: false do |ctx, seq:, params:, **|
+        render "success" + ctx[:message].to_s + seq.inspect + params.inspect
+      end
     end
 
-    def view
-      endpoint "view?"
+    # todo: test overriding endp options
+      # _endpoint "show?", params: {id: 1}, process_model: "it's me!" do |ctx, seq:, params:, process_model:, **|
+  end # DomainContextController
+
+  it "{:current_user} and {:process_model} are made available in {domain_ctx}" do
+    controller = DomainContextController.new
+    controller.process(:view, params: {}).must_equal %{successYogi / Class[:authenticate, :policy, :check]}
+  end
+
+  it "{:seq} is overridden, {:params} made available, in {domain_ctx}" do
+    controller = DomainContextController.new
+    # note that {seq} is not shared anymore
+    controller.process(:show, params: {}).must_equal %{successYogi / Class[:check]{:id=>1}}
+  end
+
+  it "allows passing {endpoint_options} directly" do
+    controller = DomainContextController.new
+    controller.process(:create, params: {}).must_equal [:authenticate, :policy, :protocol_failure_block]
+  end
+
+
+# Test without DSL
+  class BasicController
+    extend Trailblazer::Endpoint::Controller
+
+    directive :options_for_block_options, Trailblazer::Endpoint::Controller.method(:options_for_block_options)
+
+    def endpoint(name, &block)
+      action_options = {seq: []}
+
+      Trailblazer::Endpoint::Controller.advance_endpoint_for_controller(endpoint: endpoint_for(name), block_options: self.class.options_for(:options_for_block_options, {controller: self}), config_source: self.class, **action_options)
+    end
+
+    def head(status)
+      @status = status
+    end
+  end
+
+  class RodaController < BasicController
+    endpoint("show?", protocol: ApplicationController::Protocol, adapter: Trailblazer::Endpoint::Adapter::Web, domain_activity: Class.new(Trailblazer::Activity::Railway) { def save(*); true; end; step :save })
+
+    def show
+      endpoint "show?"
+      @status
     end
+  end
+
+  it "what" do
+    RodaController.new.show.must_equal 200
+  end
+end
+
+class ControllerEndpointMethodTest < Minitest::Spec
+# Test {Controller::endpoint}
+
+  class Protocol < Trailblazer::Endpoint::Protocol
+    def policy(*); true; end
+    def authenticate(*); true; end
+  end
 
-    # we add {:options_for_domain_ctx} manually
-    def download
-      endpoint "download?", params: {id: params[:other_id]}, redis: "Redis"
+  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
 
-    # override some settings from {endpoint_options}:
-    def new
-      endpoint "new?", find_process_model: false
+    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
 
-  it "allows to get options without a bloody controller" do
-    MemoController.bla(params: params)
+  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