trailblazer-endpoint 0.0.4 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f2333c41e1962d218d94a14572f7c8c955e5510b294ca0ea27ac2828898719c9
-  data.tar.gz: 0a4fc49084a5e359ec3a0780d4f63a839a25fd0d63006c02c462224ee65d3f71
+  metadata.gz: 5856f0724650869732af67c5b45eee354e68a606b97d86153dffa3271adc9ee1
+  data.tar.gz: 01504dc413db4e2dce833908d1687ba0492f157cea3a3bca58853d9615d597d5
 SHA512:
-  metadata.gz: 606002eb9724eee10e09459b4d47e0802ba84287a822283fcb1145f8b2097580e5d99942f7702d79145556226c2524112a1007f3dfa5201f8453dd5dd3ba704a
-  data.tar.gz: 3916c8bfe99dbba20f8b6f9aed7a3d2c300b7f2bcc868ab751c00f22cd6db949ea6b77977a511366cdd89a04409ae84a96a92c9987133e454cf6e500a3720a45
+  metadata.gz: 9c6322150c0dad7b568a77c8dc8b4af4a48c40e6358d18b16cf57e50f3f9515bae3e38a1875f3eb48e420192dbe978a5f7631b5b35f7c1e532e58e52d3f2043a
+  data.tar.gz: 3ff1847a6e2e59fba1d8b3713b7069d58ea7e89be250ab79d5d87b795a5141c6a2c5dd1cc653257191d07906c66c4700fd12408b03200bdc89d87b312451cf96

data/.gitignore

@@ -0,0 +1,16 @@
+.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/log
+tmp
+.DS_Store
+log/
+*.iml
+.idea
+*.swp
+gemfiles/*.lock

data/Appraisals

@@ -0,0 +1,5 @@
+appraise 'rails-app' do
+  gem 'rails', '6.0.3.1'
+  gem 'sqlite3', '~> 1.4'
+  gem "trailblazer-operation"
+end

data/CHANGES.md

@@ -1,7 +1,13 @@
+# 0.0.5
+
+* Removed `Protocol::Failure`. Until we have `Railway::End::Failure`, use a normal `Activity::End` everywhere instead of introducing our own.
+* Default `with_or_etc:invoke` is `TaskWrap.invoke`.
+
 # 0.0.4
 
 * Use new `context-0.3.1`.
 * Don't use `wtf?`.
+* Don't create a `Context` anymore in `Endpoint.arguments_for`.
 
 # 0.0.3
 

data/Rakefile

@@ -5,6 +5,12 @@ task :default => [:test]
 
 Rake::TestTask.new(:test) do |test|
   test.libs << 'test'
-  test.test_files = FileList['test/endpoint_test.rb', 'test/docs/*_test.rb', "test/adapter/*_test.rb"]
+  test.test_files = FileList['test/endpoint_test.rb', 'test/docs/*_test.rb', "test/adapter/*_test.rb", "test/config_test.rb"]
+  test.verbose = true
+end
+
+Rake::TestTask.new('test-rails-app') do |test|
+  test.libs << 'test'
+  test.test_files = FileList['test/rails-app/test/test_helper.rb', 'test/rails-app/test/**/*.rb']
   test.verbose = true
 end

data/gemfiles/rails_app.gemfile

@@ -0,0 +1,12 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "multi_json"
+gem "minitest-line"
+gem "dry-validation"
+gem "rails", "6.0.3.1"
+gem "sqlite3", "~> 1.4"
+gem "trailblazer-operation"
+
+gemspec path: "../"

data/lib/trailblazer/endpoint.rb

@@ -2,8 +2,7 @@ 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,  &block)
-
+    def self.build(protocol:, adapter:, domain_activity:, scope_domain_ctx: true, domain_ctx_filter: nil, protocol_block: ->(*) { Hash.new })
       # special considerations around the {domain_activity} and its taskWrap:
       #
       #  1. domain_ctx_filter (e.g. to filter {current_user})
@@ -24,16 +23,21 @@ module Trailblazer
       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
 
+      # puts Trailblazer::Developer.render(protocol)
+      # puts
+
       app_protocol = Class.new(protocol) do
         step(Subprocess(domain_activity), {inherit: true, id: :domain_activity, replace: :domain_activity,
 
 # FIXME: where does this go?
         }.
           merge(extensions_options).
-          merge(instance_exec(&block)) # the block is evaluated in the {Protocol} context.
+          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
@@ -47,9 +51,19 @@ 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::Developer.method(:wtf?))
+    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?)
       # args[1] = args[1].merge(focus_on: { variables: [:returned], steps: :invoke_workflow })
 
       # signal, (endpoint_ctx, _ ) = Trailblazer::Developer.wtf?(activity, args)
@@ -78,7 +92,8 @@ module Trailblazer
 
     #@ For WORKFLOW and operations. not sure this method will stay here.
     def self.arguments_for(domain_ctx:, flow_options:, circuit_options: {}, **endpoint_options)
-      domain_ctx      = Trailblazer::Context(domain_ctx, {}, flow_options[:context_options])
+      # we don't have to create the Ctx wrapping explicitly here. this is done via `:input`.
+      # domain_ctx      = Trailblazer::Context::IndifferentAccess.build(domain_ctx, {}, [domain_ctx, flow_options], circuit_options)
 
       [
         [

data/lib/trailblazer/endpoint/adapter.rb

@@ -9,20 +9,32 @@ module Trailblazer
 
 
     module Adapter
-      class Web <Trailblazer::Activity::FastTrack
+      class Web < Trailblazer::Activity::Path
         _404_path = ->(*) { step :_404_status }
         _401_path = ->(*) { step :_401_status }
         _403_path = ->(*) { step :_403_status }
         # _422_path = ->(*) { step :_422_status } # TODO: this is currently represented by the {failure} track.
 
+        # 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: Activity::End.new(semantic: :fail_fast), magnetic_to: :fail_fast, id: "End.fail_fast") # TODO: rename to {protocol_failure}
+          sequence = Activity::Path::DSL.append_end(sequence, task: Activity::End.new(semantic: :failure), magnetic_to: :failure, id: "End.failure")
+
+          recompile_activity!(sequence)
+
+          sequence
+        end
+
         step Subprocess(Protocol), # this will get replaced
           id: :protocol,
           Output(:not_authorized)     => Path(track_color: :not_authorized, connect_to: Id(:protocol_failure), &_403_path),
           Output(:not_found)          => Path(track_color: :not_found, connect_to: Id(:protocol_failure), &_404_path),
           Output(:not_authenticated)  => Path(track_color: :not_authenticated, connect_to: Id(:protocol_failure), &_401_path),
-          Output(:invalid_data)       => Track(:failure) # application error, since it's usually a failed validation.
+          Output(:invalid_data)       => Track(:failure), # application error, since it's usually a failed validation.
+          Output(:failure)       => Track(:failure) # application error, since it's usually a failed validation.
+
+        step :protocol_failure, magnetic_to: nil, Output(:success) => Track(:fail_fast)#, Output(:failure) => Track(:fail_fast)
 
-        step :protocol_failure, magnetic_to: nil, Output(:success) => Track(:fail_fast), Output(:failure) => Track(:fail_fast)
 
         def protocol_failure(ctx, **)
           true
@@ -41,28 +53,34 @@ module Trailblazer
         def _403_status(ctx, **)
           ctx[:status] = 403
         end
-      end
+      end # Web
 
       class API < Web
         step :_200_status, after: :protocol
 
-        def _200_status(ctx, **)
-          ctx[:status] = 200
+        def _200_status(ctx, success_status: 200, **)
+          ctx[:status] = success_status
         end
 
-        fail :_422_status, before: "End.failure"
+        step :_422_status, before: "End.failure", magnetic_to: :failure, Output(:success) => Track(:failure)
 
         def _422_status(ctx, **)
           ctx[:status] = 422
         end
 
 
-        def self.insert_error_handler_steps(adapter)
+        def self.insert_error_handler_steps(adapter) # TODO: evaluate if needed?
           adapter = Class.new(adapter) do
-            step :handle_not_authenticated, magnetic_to: :not_authenticated, Output(:success) => Track(:not_authenticated), Output(:failure) => Track(:not_authenticated), before: :_401_status
-            step :handle_not_authorized, magnetic_to: :not_authorized, Output(:success) => Track(:not_authorized), Output(:failure) => Track(:not_authorized), before: :_403_status
+            API.insert_error_handler_steps!(self)
+          end
+        end
+
+        def self.insert_error_handler_steps!(adapter)
+          adapter.instance_exec do
+            step :handle_not_authenticated, magnetic_to: :not_authenticated, Output(:success) => Track(:not_authenticated), before: :_401_status
+            step :handle_not_authorized, magnetic_to: :not_authorized, Output(:success) => Track(:not_authorized), before: :_403_status
             # step :handle_not_found, magnetic_to: :not_found, Output(:success) => Track(:not_found), Output(:failure) => Track(:not_found)
-            fail :handle_invalid_data
+            step :handle_invalid_data, before: :_422_status, magnetic_to: :failure, Output(:success) => Track(:failure)
           end
         end
 
@@ -81,117 +99,8 @@ module Trailblazer
             end
           end
         end
-      end
-
-      # Basic endpoint adapter for a HTTP document API.
-      # As always: "work in progress" ;)
-      #
-      # {End.fail_fast} currently implies a 4xx-able error.
-      class API_ < Trailblazer::Activity::FastTrack
-        _404_path = ->(*) { step :_404_status }
-        _401_path = ->(*) { step :_401_status; step :_401_error_message }
-        _403_path = ->(*) { step :_403_status }
-        # _422_path = ->(*) { step :_422_status } # TODO: this is currently represented by the {failure} track.
-
-        # The API Adapter automatically wires well-defined outputs for you to well-defined paths. :)
-# FIXME
-
-        step Subprocess(Protocol), # this will get replaced
-          id: :protocol,
-          Output(:not_authorized)     => Path(track_color: :_403, connect_to: Id(:render_protocol_failure_config), &_403_path),
-          Output(:not_found)          => Path(track_color: :_404, connect_to: Id(:protocol_failure), &_404_path),
-          Output(:not_authenticated)  => Path(track_color: :_401, connect_to: Id(:render_protocol_failure_config), &_401_path),       # head(401), representer: Representer::Error, message: no token
-          Output(:invalid_data)       => Track(:failure) # application error, since it's usually a failed validation.
-
-            # extensions: [Trailblazer::Activity::TaskWrap::Extension(merge: TERMINUS_HANDLER)]
-            # failure is automatically wired to failure, being an "application error" vs. a "protocol error (auth, etc)"
-
-
-            fail :failure_render_config
-            fail :failure_config_status
-            fail :render_failure
-
-            step :success_render_config
-            step :success_render_status
-            step :render_success
-
-
-          # DISCUSS: "protocol failure" and "application failure" should be the same path, probably?
-          step :render_protocol_failure_config, magnetic_to: nil, Output(:success) => Path(connect_to: Id("End.fail_fast")) do
-            step :render_protocol_failure
-            step :protocol_failure
-          end
-
-=begin
-          render_protocol_failure_config # representer
-          render_protocol_failure        # Representer.new
-          protocol_failure               # true
-=end
-
-        def success_render_status(ctx, **)
-          ctx[:status] = 200
-        end
-
-        def success_render_config(ctx, representer:, **)
-          true
-        end
-
-        def render_protocol_failure_config(*args)
-          failure_render_config(*args)
-        end
-
-# ROAR
-        def render_success(ctx, representer:, domain_ctx:, **)
-          model = domain_ctx[:model]
-          ctx[:json] = representer.new(model).to_json # FIXME: use the same as render_failure.
-        end
-
-        def failure_render_config(ctx, error_representer:, **)
-          ctx[:representer] = error_representer
-        end
-
-        def failure_config_status(ctx, **)
-          ctx[:status] = 422
-        end
-
-        def protocol_failure(*args)
-          #failure_config(*args)
-          true
-        end
-        def render_protocol_failure(*args)
-          render_failure(*args)
-        end
-
-      # ROAR
-        def render_failure(ctx, error_representer:, errors:, **)
-          # render_success(*args)
-          ctx[:json] = error_representer.new(errors).to_json
-      end
-  # how/where would we configure each endpoint? (per action)
-    # class Endpoint
-    #   representer ...
-    #   message ...
-
-        def _401_status(ctx, **)
-          ctx[:status] = 401
-        end
-
-        def _404_status(ctx, **)
-          ctx[:status] = 404
-        end
-
-        def _403_status(ctx, **)
-          ctx[:status] = 403
-        end
-
-        def _401_error_message(ctx, **)
-          ctx[:error_message] = "Authentication credentials were not provided or invalid."
-        end
+      end # API
 
-        # def exec_success(ctx, success_block:, **)
-        #   success_block.call(ctx, **ctx.to_hash) # DISCUSS: use Nested(dynamic) ?
-        # end
-      end
     end
   end
 end

data/lib/trailblazer/endpoint/builder.rb

@@ -35,7 +35,7 @@ module Trailblazer
         def endpoint_for(id:, builder:, default_options:, **config)
           options = build_options_for(builder: builder, **config)
 
-          return id, Trailblazer::Endpoint.build(default_options.merge(options[:options_for_build]), &options[:protocol_block])
+          return id, Trailblazer::Endpoint.build(default_options.merge(options[:options_for_build]).merge(protocol_block: options[:protocol_block]))
         end
 
         # {dsl_options} being something like

data/lib/trailblazer/endpoint/controller.rb

@@ -1,7 +1,209 @@
 module Trailblazer
   class Endpoint
     module Controller
+      def self.extended(extended)
+        extended.extend Trailblazer::Endpoint::Options::DSL
+        extended.extend Trailblazer::Endpoint::Options::DSL::Inherit
+        extended.extend Trailblazer::Endpoint::Options
+        extended.extend DSL::Endpoint
 
-    end
+        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
+      def self.module(framework: :rails, api: false, dsl: false, application_controller: false)
+        if api
+          Module.new do
+            def self.included(includer)
+              includer.extend(Controller)
+              includer.include(InstanceMethods)
+              includer.include(InstanceMethods::API)
+            end
+          end
+        elsif dsl and !application_controller
+          Module.new do
+            def self.included(includer)
+              # includer.extend Trailblazer::Endpoint::Controller
+              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
+      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, **options)
+            puts "~~~~~~~~~~~~~~~config"
+            build_options = options_for(:generic_options, {}).merge(options) # DISCUSS: why don't we add this as another directive option/step?
+
+            endpoint = Trailblazer::Endpoint.build(build_options)
+
+            directive :endpoints, ->(*) { {name => endpoint} }
+          end
+
+        end
+      end
+
+      module InstanceMethods
+
+        def endpoint_for(name, config_source: self.class)
+          config_source.options_for(:endpoints, {}).fetch(name) # 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}
+
+            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 {DSL#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