trailblazer-endpoint 0.0.1 → 0.0.6

data/lib/trailblazer/endpoint/controller.rb

@@ -0,0 +1,223 @@
+module Trailblazer
+  class Endpoint
+    module Controller
+      def self.extended(extended)
+        extended.extend Trailblazer::Endpoint::Options::DSL           # ::directive
+        extended.extend Trailblazer::Endpoint::Options::DSL::Inherit
+        extended.extend Trailblazer::Endpoint::Options                # ::options_for
+        extended.extend DSL::Endpoint
+
+        extended.include InstanceMethods # {#endpoint_for}
+
+        # DISCUSS: hmm
+        extended.directive :generic_options,          ->(*) { Hash.new } # for Controller::endpoint
+        extended.directive :options_for_flow_options, ->(*) { Hash.new }
+        extended.directive :options_for_endpoint,     ->(*) { Hash.new }
+        extended.directive :options_for_domain_ctx,   ->(*) { Hash.new }
+      end
+
+      # @experimental
+      # TODO: test application_controller with and without dsl/api
+
+      def self.module(framework: :rails, api: false, dsl: false, application_controller: false)
+        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)
+              if @application_controller
+                includer.extend Controller
+              end
+              includer.include(InstanceMethods::API)
+            end
+          end
+        elsif dsl
+          Module.new do
+            @application_controller = application_controller
+            def self.included(includer)
+              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 # Module
+        else
+          raise
+        end
+      end
+
+      module Rails
+        module Process
+          def send_action(action_name)
+      puts "@@@@@>>>>>>> #{action_name.inspect}"
+
+            dsl = send(action_name) # call the actual controller action.
+
+            options, block_options = dsl.to_args(self.class.options_for(:options_for_block_options, controller: self)) # {success_block:, failure_block:, protocol_failure_block:}
+            # now we know the authorative blocks
+
+            Controller.advance_endpoint_for_controller(**options, block_options: block_options, config_source: self.class, controller: self)
+          end
+
+        end # Process
+
+        # The three default handlers for {Endpoint::with_or_etc}
+        # @experimental
+        module DefaultBlocks
+          def self.extended(extended)
+            extended.directive :options_for_block_options, Controller.method(:options_for_block_options)
+          end
+        end
+        # @experimental
+        module DefaultParams
+          def self.extended(extended)
+            extended.directive :options_for_domain_ctx, ->(ctx, controller:, **) { {params: controller.params} }
+          end
+        end
+
+      end # Rails
+
+      module DSL
+        module Endpoint
+          def self.extended(extended)
+            extended.directive(:endpoints, ->(*) { {} })
+          end
+
+          def endpoint(name, **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)
+          end
+
+          def generic_endpoint_config(protocol:, adapter:, **options)
+            self.singleton_class.define_method :generic_options do |ctx,**|
+              {
+                protocol: protocol,
+                adapter: adapter,
+                **options
+              }
+            end
+
+            directive :generic_options, method(:generic_options) # FIXME: do we need this?
+          end
+
+          def endpoint_config(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)
+
+            directive :endpoints, ->(*) { {name.to_s => endpoint} }
+          end
+
+        end
+      end
+
+      module InstanceMethods
+
+        def endpoint_for(name, config_source: self.class)
+          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 {API#endpoint}
+
+            endpoint = endpoint_for(name)
+
+            invoke_endpoint_with_dsl(endpoint: endpoint, **action_options, &block)
+          end
+
+          def invoke_endpoint_with_dsl(options, &block)
+            _dsl = Trailblazer::Endpoint::DSL::Runtime.new(options, block) # provides #Or etc, is returned to {Controller#call}
+          end
+        end
+
+        module API
+          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 {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)
+
+            signal, (ctx, _) = Trailblazer::Endpoint::Controller.advance_endpoint_for_controller(
+              endpoint:       endpoint,
+              block_options:  block_options,
+              config_source:  config_source,
+              **action_options
+            )
+
+            ctx
+          end
+        end # API
+      end
+
+
+      def self.advance_endpoint_for_controller(endpoint:, block_options:, **action_options)
+        domain_ctx, endpoint_options, flow_options = compile_options_for_controller(**action_options) # controller-specific, get from directives.
+
+        endpoint_options = endpoint_options.merge(action_options) # DISCUSS
+
+        Endpoint::Controller.advance_endpoint(
+          endpoint:      endpoint,
+          block_options: block_options,
+
+          domain_ctx:       domain_ctx,
+          endpoint_options: endpoint_options,
+          flow_options:     flow_options,
+        )
+      end
+
+      def self.compile_options_for_controller(options_for_domain_ctx: nil, config_source:, **action_options)
+        flow_options     = config_source.options_for(:options_for_flow_options, **action_options)
+        endpoint_options = config_source.options_for(:options_for_endpoint, **action_options) # "class level"
+        domain_ctx       = options_for_domain_ctx || config_source.options_for(:options_for_domain_ctx, **action_options)
+
+        return domain_ctx, endpoint_options, flow_options
+      end
+
+      # Ultimate low-level entry point.
+      # Remember that you don't _have_ to use Endpoint.with_or_etc to invoke an endpoint.
+      def self.advance_endpoint(endpoint:, block_options:, domain_ctx:, endpoint_options:, flow_options:)
+
+        # build Context(ctx),
+        args, _ = Trailblazer::Endpoint.arguments_for(
+          domain_ctx:   domain_ctx,
+          flow_options: flow_options,
+          **endpoint_options,
+        )
+
+        signal, (ctx, _ ) = Trailblazer::Endpoint.with_or_etc(
+          endpoint,
+          args, # [ctx, flow_options]
+
+          **block_options,
+          # success_block: success_block,
+          # failure_block: failure_block,
+          # protocol_failure_block: protocol_failure_block,
+        )
+      end
+
+      # Default blocks for the {Adapter}.
+      def self.options_for_block_options(ctx, controller:, **)
+        {
+          success_block:          ->(ctx, endpoint_ctx:, **) { controller.head 200 },
+          failure_block:          ->(ctx, **) { controller.head 422 },
+          protocol_failure_block: ->(ctx, endpoint_ctx:, **) { controller.head endpoint_ctx[:status] }
+        }
+      end
+
+    end # Controller
+  end
+end

data/lib/trailblazer/endpoint/dsl.rb

@@ -0,0 +1,29 @@
+module Trailblazer
+  class Endpoint
+    module DSL
+      # Run before the endpoint is invoked. This collects the blocks from the controller.
+      class Runtime < Struct.new(:options, :success_block, :failure_block, :protocol_failure_block)
+
+        def failure(&block)
+          self.failure_block = block
+          self
+        end
+
+        alias_method :Or, :failure
+
+        def protocol_failure(&block)
+          self.protocol_failure_block = block
+          self
+        end
+
+        # #call
+        def to_args(default_block_options)
+          return options,
+            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
+  end
+end

data/lib/trailblazer/endpoint/options.rb

@@ -0,0 +1,92 @@
+# DISCUSS: the generic inheritance/Options logic might be extracted to trailblazer-config or something.
+#          it is completely independent and could be helpful for many other configurations.
+module Trailblazer
+  class Endpoint
+    module Options
+      module DSL
+        def directive(directive_name, *callables, inherit: superclass)
+          options = {}
+
+          if inherit
+            options[:base_class] = instance_variable_get(:@normalizers)[directive_name] || Trailblazer::Activity::Path # FIXME
+          end
+
+          @normalizers[directive_name] = Trailblazer::Endpoint::Normalizer.Options(directive_name, *callables, **options) # DISCUSS: allow multiple calls?
+        end
+
+        # Called in {Endpoint::Controller}.
+        def self.extended(extended) # TODO: let's hope this is only called once per hierachy :)
+          extended.instance_variable_set(:@normalizers, {})
+        end
+
+        module Inherit
+          def inherited(subclass)
+            super
+
+            subclass.instance_variable_set(:@normalizers, @normalizers.dup)
+          end
+        end
+      end
+
+      def options_for(directive_name, runtime_options)
+        normalizer = @normalizers.fetch(directive_name)
+
+        ctx = Trailblazer::Context(runtime_options, {})
+
+        # signal, (ctx, ) = Trailblazer::Developer.wtf?(normalizer, [ctx])
+        signal, (ctx, ) = Trailblazer::Activity::TaskWrap.invoke(normalizer, [ctx])
+
+        _, options = ctx.decompose
+        options
+      end
+
+
+      # Merge {merged} into {hash}, but only keys that exist in {hash}.
+      def self.merge_with(merged, hash)
+        keys = hash.keys
+        merged = keys.collect { |key| merged.key?(key) ? [key, merged[key]] : nil }.compact.to_h
+        hash.merge(merged)
+      end
+    end # Options
+
+    module Normalizer
+      def self.Options(directive_name, *callables, base_class: Trailblazer::Activity::Path)
+        normalizer = Class.new(base_class) do
+        end
+
+        Normalizer.add(normalizer, directive_name, callables)
+      end
+
+      def self.DefaultToEmptyHash(config_name)
+        -> (ctx, **) { ctx[config_name] ||= {} }
+      end
+
+      def self.add_normalizer!(target, normalizer, config)
+        normalizer = Normalizer.add(normalizer, target, config) # add configure steps for {subclass} to the _new_ normalizer.
+        target.instance_variable_set(:@normalizer, normalizer)
+        target.instance_variable_set(:@config, config)
+      end
+
+      def self.add(normalizer, directive_name, options)
+        Class.new(normalizer) do
+          options.collect do |callable|
+            step task: Normalizer.CallDirective(callable, directive_name), id: "#{directive_name}=>#{callable}"
+          end
+        end
+      end
+
+      def self.CallDirective(callable, option_name)
+        ->((ctx, flow_options), *) {
+          config = callable.(ctx, **ctx) # e.g. ApplicationController.options_for_endpoint
+
+          # ctx[option_name] = ctx[option_name].merge(config)
+          config.each do |k, v|
+            ctx[k] = v
+          end
+
+          return Trailblazer::Activity::Right, [ctx, flow_options]
+        }
+      end
+    end # Normalizer
+  end
+end

data/lib/trailblazer/endpoint/protocol.rb

@@ -1,3 +1,5 @@
+require "trailblazer/activity/dsl/linear"
+
 module Trailblazer
   class Endpoint
     # The {Protocol} implements auth*, and calls the domain OP/WF.
@@ -16,13 +18,8 @@ module Trailblazer
       class Noop < Trailblazer::Activity::Railway
       end
 
-      class Failure < Trailblazer::Activity::End # DISCUSS: move to Act::Railway?
-        # class Authentication < Failure
-        # end
-      end
-
       def self._Path(semantic:, &block) # DISCUSS: the problem with Path currently is https://github.com/trailblazer/trailblazer-activity-dsl-linear/issues/27
-        Path(track_color: semantic, end_id: "End.#{semantic}", end_task: Failure.new(semantic: semantic), &block)
+        Path(track_color: semantic, end_id: "End.#{semantic}", end_task: Activity::End.new(semantic: semantic), &block)
       end
 
       step :authenticate, Output(:failure) => _Path(semantic: :not_authenticated) do
@@ -43,8 +40,8 @@ module Trailblazer
       # termini for the Adapter this is the only way to get it working right now.
       # FIXME: is this really the only way to add an {End} to all this?
       @state.update_sequence do |sequence:, **|
-        sequence = Activity::Path::DSL.append_end(sequence, task: Failure.new(semantic: :not_found), magnetic_to: :not_found, id: "End.not_found")
-        sequence = Activity::Path::DSL.append_end(sequence, task: Failure.new(semantic: :invalid_data), magnetic_to: :invalid_data, id: "End.invalid_data")
+        sequence = Activity::Path::DSL.append_end(sequence, task: Activity::End.new(semantic: :not_found), magnetic_to: :not_found, id: "End.not_found")
+        sequence = Activity::Path::DSL.append_end(sequence, task: Activity::End.new(semantic: :invalid_data), magnetic_to: :invalid_data, id: "End.invalid_data")
 
         recompile_activity!(sequence)
 

data/lib/trailblazer/endpoint/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   class Endpoint
-    VERSION = "0.0.1"
+    VERSION = "0.0.6"
   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