trailblazer-endpoint 0.0.2 → 0.0.7

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.2"
+    VERSION = "0.0.7"
   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

@@ -0,0 +1,128 @@
+require "test_helper"
+
+require "trailblazer/endpoint/options"
+
+class ConfigTest < Minitest::Spec
+  Controller = Struct.new(:params)
+
+  it "what" do
+    ApplicationController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true}}
+
+  # inherits endpoint options from ApplicationController
+    ApeController.options_for(:options_for_endpoint, {}).inspect.must_equal %{{:find_process_model=>true, :request=>true}}
+  # defines its own domain options, none in ApplicationController
+    ApeController.options_for(:options_for_domain_ctx, {}).inspect.must_equal %{{:current_user=>\"Yo\"}}
+
+    # 3-rd level, inherit everything from 2-nd level
+    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, **)
+      {
+        find_process_model: true,
+      }
+    end
+
+    def self.request_options(ctx, **)
+      {
+        request: true,
+      }
+    end
+
+    extend Trailblazer::Endpoint::Controller
+    directive :options_for_endpoint, method(:options_for_endpoint), method(:request_options)
+  end
+
+  class ApeController < ApplicationController
+    def self.options_for_domain_ctx(ctx, **)
+      {
+        current_user: "Yo",
+      }
+    end
+
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+  end
+
+  class ApeBabeController < ApeController
+    # def self.options_for_domain_ctx(ctx, **)
+    #   {policy: "Ehm"}
+    # end
+
+    # 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
+
+    directive :options_for_endpoint,   method(:options_for_endpoint) #, inherit: ApplicationController
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
+  end
+
+  class OverridingController < BoringController
+    def self.options_for_domain_ctx(ctx, **)
+      {
+        redis: "Arrr",
+      }
+    end
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx), inherit: false
+  end
+end
+
+class RuntimeOptionsTest < Minitest::Spec
+  class ApplicationController
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        option: true,
+        params: controller[:params],
+      }
+    end
+
+  # You can access variables set prior to this options directive.
+    def self.request_options(ctx, controller:, params:, **)
+      {
+        my_params: params.inspect,
+        option: nil,
+      }
+    end
+
+    extend Trailblazer::Endpoint::Controller
+    directive :options_for_endpoint, method(:options_for_endpoint), method(:request_options)
+  end
+
+  it do
+    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,92 +1,374 @@
 require "test_helper"
 
 class DocsControllerTest < Minitest::Spec
-  it "what" do
-    endpoint "view?" do |ctx|
-      # 200, success
-      return
+  class ApplicationController
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        find_process_model: true,
+        **controller.instance_variable_get(:@params)[:params],
+      }
+    end
+
+    def self.request_options(ctx, **)
+      {
+        request: true,
+      }
+    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
 
-    # 422
-    # but also 404 etc
+
+    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)
+      @params = params
+      send_action(action_name)
+      @render
+    end
+
+    def render(text)
+      @render = text
+    end
+
+
+
+
+    Protocol = Class.new(Trailblazer::Endpoint::Protocol) do
+      include T.def_steps(:authenticate, :policy)
+    end
+
+    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
+        include T.def_steps(:authenticate, :policy)
+      end
+
+      endpoint =
+        Trailblazer::Endpoint.build(
+          domain_activity: Minitest::Spec.new(nil).activity, # FIXME
+          protocol: protocol,
+          adapter: Trailblazer::Endpoint::Adapter::Web,
+          scope_domain_ctx: true,
+
+      ) do
+        {Output(:not_found) => Track(:not_found)}
+      end
+    end
+
+    def self.options_for_domain_ctx(ctx, seq:, controller:, **)
+      {
+        current_user: "Yo",
+        seq: seq,
+        **controller.instance_variable_get(:@params)[:params],
+      }
+    end
+
+    directive :options_for_domain_ctx, method(:options_for_domain_ctx)
 
-  class Controller
-    def initialize(endpoint, activity)
-      @___activity = activity
-      @endpoint = endpoint
-      @seq      = []
+    private def _endpoint(action, seq: [], &block)
+      endpoint(action, seq: seq, &block)
     end
 
-    def view(params)
-      endpoint "view?", params do |ctx|
-        @seq << :success
-        # 200, success
-        return
+    # 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
+
+      end.protocol_failure do |ctx, seq:, **|
+        render "protocol_failure" + ctx[:current_user] + seq.inspect
       end
+    end
 
-      @seq << :failure
-      # 422
-      # but also 404 etc
+    # standard use-case: only success
+    def show
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx[:current_user] + seq.inspect
+      end
     end
 
-    def call(action, **params)
-      send(action, **params)
-      @seq
+    # standard use case: {success} and {failure}
+    def update
+      _endpoint "view?" do |ctx, seq:, **|
+        render "success" + ctx[:current_user] + seq.inspect
+      end.Or do |ctx, seq:, **|
+        render "Fail!" + ctx[:current_user] + seq.inspect
+      end
     end
 
-    private def endpoint(action, params, &block)
-      ctx = Trailblazer::Endpoint.advance_from_controller(@endpoint,
-        event_name:             "",
-        success_block: block,
-        failure_block: ->(*) { return },
-        protocol_failure_block: ->(*) { @seq << 401 and return },
+  end # HtmlController
+
+  it "what" do
+  # success
+    controller = HtmlController.new
+    controller.process(:view, params: {}).must_equal %{successYo[:authenticate, :policy, :model, :validate]}
 
-        collaboration: @___activity,
-        domain_ctx: {},
-        success_id: "fixme",
-        flow_options: {},
+  # failure
+    controller = HtmlController.new
+    controller.process(:view, params: {validate: false}).must_equal %{failureYo[:authenticate, :policy, :model, :validate]}
 
-        **params,
+  # protocol_failure
+    controller = HtmlController.new
+    controller.process(:view, params: {authenticate: false}).must_equal %{protocol_failureYo[:authenticate]}
+  end
 
-      # DISCUSS: do we really like that fuzzy API? if yes, why do we need {additional_endpoint_options} or whatever it's called?
-        seq: @seq,
-      )
+  it "only success_block is user-defined" do
+  # success
+    controller = HtmlController.new
+    controller.process(:show, params: {}).must_equal %{successYo[:authenticate, :policy, :model, :validate]}
+
+  # failure
+    controller = HtmlController.new
+    # from controller-default
+    controller.process(:show, params: {validate: false}).must_equal [:authenticate, :policy, :model, :validate, :failure_block]
+
+  # protocol_failure
+    controller = HtmlController.new
+    # from controller-default
+    controller.process(:show, params: {authenticate: false}).must_equal [:authenticate, :protocol_failure_block]
+  end
+
+  it "success/Or" do
+  # success
+    controller = HtmlController.new
+    controller.process(:update, params: {}).must_equal %{successYo[:authenticate, :policy, :model, :validate]}
+
+  # failure
+    controller = HtmlController.new
+    # from controller-default
+    controller.process(:update, params: {validate: false}).must_equal %{Fail!Yo[:authenticate, :policy, :model, :validate]}
+
+  # protocol_failure
+    controller = HtmlController.new
+    # from controller-default
+    controller.process(:update, params: {authenticate: false}).must_equal [:authenticate, :protocol_failure_block]
+  end
+
+
+# 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
+
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        current_user: "Yogi",
+        process_model: Class,
+      }
+    end
+
+    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
 
-  it "injected {return} interrupts the controller action" do
-    protocol = Class.new(Trailblazer::Endpoint::Protocol)do
-      include T.def_steps(:authenticate, :policy)
+
+# copy from {endpoint_ctx} to {domain_ctx}
+  class DomainContextController < ApplicationController
+    private def _endpoint(action, seq: [], **options, &block)
+      endpoint(action, seq: seq, **options, &block)
     end
 
-    endpoint =
-      Trailblazer::Endpoint.build(
-        domain_activity: activity,
-        protocol: protocol,
-        adapter: Trailblazer::Endpoint::Adapter::Web,
-        scope_domain_ctx: false,
+    Activity = Class.new(Trailblazer::Activity::Railway) do
+      step :check
 
-    ) do
-      {Output(:not_found) => Track(:not_found)}
+      def check(ctx, current_user:, seq:, process_model:, **)
+        seq << :check
+        ctx[:message] = "#{current_user} / #{process_model}"
+      end
     end
 
-  # 200
-    seq = Controller.new(endpoint, activity).call(:view)
-    seq.must_equal [:authenticate, :policy, :model, :validate, :success] # the {return} works.
+    endpoint "view?", domain_activity: Activity
+    endpoint "show?", domain_activity: Activity
+
 
-  # 401
-    seq = Controller.new(endpoint, activity).call(:view, authenticate: false)
-    seq.must_equal [:authenticate, :policy, :model, :validate, :success]
+    def self.options_for_domain_ctx(ctx, seq:, controller:, **)
+      {
+        seq: seq,
+      }
+    end
+
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        current_user: "Yogi",
+        process_model: Class,
+        something: true,
+      }
+    end
+
+    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
+
+    # 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
-    endpoint "view?" do |ctx|
-      # 200, success
-      return
-    end.Or() do |ctx|
-      # Only 422
+    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
+
+  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
+