trailblazer-endpoint 0.0.5 → 0.0.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5856f0724650869732af67c5b45eee354e68a606b97d86153dffa3271adc9ee1
-  data.tar.gz: 01504dc413db4e2dce833908d1687ba0492f157cea3a3bca58853d9615d597d5
+  metadata.gz: 4dd0d753bd8dc039e3f55e66d80d3d9d4904fcc0d442ea62860fbab4a0b05d5e
+  data.tar.gz: 0ecfa53ed1607d4d3785d47ffef3f817033b18ec29c6cbbf06e4f466c90a2638
 SHA512:
-  metadata.gz: 9c6322150c0dad7b568a77c8dc8b4af4a48c40e6358d18b16cf57e50f3f9515bae3e38a1875f3eb48e420192dbe978a5f7631b5b35f7c1e532e58e52d3f2043a
-  data.tar.gz: 3ff1847a6e2e59fba1d8b3713b7069d58ea7e89be250ab79d5d87b795a5141c6a2c5dd1cc653257191d07906c66c4700fd12408b03200bdc89d87b312451cf96
+  metadata.gz: 7762ada8e3fafbd1a68e5f4045af8e57b03568745ac55236d756da6a4fe681f6818abd4e27b737b162872b9ebd4589f440b1b7ebee01729d2cfd6dd88702d980
+  data.tar.gz: 6f56d293369de1da783002e8d9f602f2847eafbe2f7ad80f5f6a08fc305542f3d432d7c9878376cc421a38de58e19d60eac2d436fe2650191b36f66d149bb722

data/CHANGES.md

@@ -1,3 +1,9 @@
+# 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.rb

@@ -63,7 +63,9 @@ module Trailblazer
 
     # 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)

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
 
@@ -96,13 +111,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 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 => endpoint} }
+            directive :endpoints, ->(*) { {name.to_s => endpoint} }
           end
 
         end
@@ -111,12 +125,12 @@ 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)
 
@@ -132,7 +146,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/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/version.rb

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

data/test/docs/controller_test.rb

@@ -311,4 +311,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

@@ -17,3 +17,7 @@ gem "trailblazer-operation"
 gem "trailblazer-endpoint", path: "../../."
 gem "jwt"
 gem "multi_json"
+gem "minitest-line"
+gem "trailblazer-cells"
+gem "cells-erb"
+gem "cells-rails"

data/test/rails-app/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: ../..
   specs:
-    trailblazer-endpoint (0.0.4)
+    trailblazer-endpoint (0.0.5)
       trailblazer-activity-dsl-linear (>= 0.3.0, < 0.4.0)
 
 GEM
@@ -63,10 +63,25 @@ GEM
       tzinfo (~> 1.1)
       zeitwerk (~> 2.2, >= 2.2.2)
     builder (3.2.4)
+    cells (4.1.7)
+      declarative-builder (< 0.2.0)
+      declarative-option (< 0.2.0)
+      tilt (>= 1.4, < 3)
+      uber (< 0.2.0)
+    cells-erb (0.1.0)
+      cells (~> 4.0)
+      erbse (>= 0.1.1)
+    cells-rails (0.1.1)
+      actionpack (>= 5.0)
+      cells (>= 4.1.6, < 5.0.0)
     concurrent-ruby (1.1.7)
     crass (1.0.6)
     declarative (0.0.20)
+    declarative-builder (0.1.0)
+      declarative-option (< 0.2.0)
     declarative-option (0.1.0)
+    erbse (0.1.4)
+      temple
     erubi (1.9.0)
     globalid (0.4.2)
       activesupport (>= 4.2.0)
@@ -87,6 +102,8 @@ GEM
     mini_mime (1.0.2)
     mini_portile2 (2.4.0)
     minitest (5.14.2)
+    minitest-line (0.6.5)
+      minitest (~> 5.0)
     multi_json (1.15.0)
     nio4r (2.5.2)
     nokogiri (1.10.10)
@@ -133,12 +150,16 @@ GEM
       activesupport (>= 4.0)
       sprockets (>= 3.0.0)
     sqlite3 (1.4.2)
+    temple (0.8.2)
     thor (1.0.1)
     thread_safe (0.3.6)
+    tilt (2.0.10)
     trailblazer-activity (0.11.3)
       trailblazer-context (>= 0.3.1, < 0.4.0)
     trailblazer-activity-dsl-linear (0.3.2)
       trailblazer-activity (>= 0.11.2, < 1.0.0)
+    trailblazer-cells (0.0.3)
+      cells (>= 4.1.0.rc1, < 5.0.0)
     trailblazer-context (0.3.1)
       hashie (~> 4.1)
     trailblazer-developer (0.0.16)
@@ -162,10 +183,14 @@ PLATFORMS
   ruby
 
 DEPENDENCIES
+  cells-erb
+  cells-rails
   jwt
+  minitest-line
   multi_json
   rails (~> 6.0.3, >= 6.0.3.1)
   sqlite3 (~> 1.4)
+  trailblazer-cells
   trailblazer-endpoint!
   trailblazer-operation
 

data/test/rails-app/app/concepts/song/cell/create.rb

@@ -0,0 +1,4 @@
+module Song::Cell
+  class Create < Trailblazer::Cell
+  end
+end

data/test/rails-app/app/concepts/song/cell/new.rb

@@ -0,0 +1,4 @@
+module Song::Cell
+  class New < Trailblazer::Cell
+  end
+end

data/test/rails-app/app/concepts/song/operation/create.rb

@@ -1,6 +1,6 @@
 module Song::Operation
   class Create < Trailblazer::Operation
-    # include Trailblazer::Activity::Testing.def_steps(:model, :validate, :save)
+    step :contract
     step :model
     # step :validate
     # step :save
@@ -9,5 +9,9 @@ module Song::Operation
       return unless params[:id]
       ctx[:model] = Song.new(params[:id])
     end
+
+    def contract(ctx, **)
+      ctx[:contract] = Struct.new(:errors).new()
+    end
   end
 end

data/test/rails-app/app/concepts/song/view/create.erb

@@ -0,0 +1 @@
+<div><%= model %><%= options[:current_user] %></div>

data/test/rails-app/app/concepts/song/view/new.erb

@@ -0,0 +1 @@
+<div><%= model %></div>

data/test/rails-app/app/controllers/api/v1/songs_controller.rb

@@ -1,34 +1,40 @@
 #:controller
 module Api
   module V1
+    #:endpoint
     class SongsController < ApplicationController::Api
-      endpoint Song::Operation::Create.to_s, domain_activity: Song::Operation::Create
-      endpoint Song::Operation::Show.to_s, domain_activity: Song::Operation::Show do {Output(:not_found) => Track(:not_found)} end
+      endpoint Song::Operation::Create
+      endpoint Song::Operation::Show do
+        {Output(:not_found) => Track(:not_found)}  # add additional wiring to {domain_activity}
+      end
+    #:endpoint end
 
       #:create
       def create
-        endpoint Song::Operation::Create.to_s, representer_class: Song::Representer
+        endpoint Song::Operation::Create, representer_class: Song::Representer
       end
       #:create end
 
+      #~empty
       def show
-        endpoint Song::Operation::Show.to_s, representer_class: Song::Representer
+        endpoint Song::Operation::Show, representer_class: Song::Representer
       end
 
       def show_with_options
-        endpoint Song::Operation::Show.to_s, representer_class: Song::Representer, protocol_failure_block: ->(ctx, endpoint_ctx:, **) { head endpoint_ctx[:status] + 1 }
+        endpoint Song::Operation::Show, representer_class: Song::Representer, protocol_failure_block: ->(ctx, endpoint_ctx:, **) { head endpoint_ctx[:status] + 1 }
       end
 
       class WithOptionsController < ApplicationController::Api
-        endpoint Song::Operation::Show.to_s, domain_activity: Song::Operation::Show do {Output(:not_found) => Track(:not_found)} end
+        endpoint Song::Operation::Show do {Output(:not_found) => Track(:not_found)} end
 
         #:show-options
         def show
-          endpoint Song::Operation::Show.to_s, representer_class: Song::Representer,
+          endpoint Song::Operation::Show, representer_class: Song::Representer,
             protocol_failure_block: ->(ctx, endpoint_ctx:, **) { head endpoint_ctx[:status] + 1 }
         end
         #:show-options end
       end
+      #~empty end
     end
   end
 end

data/test/rails-app/app/controllers/application_controller.rb

@@ -1,7 +1,9 @@
 require "trailblazer/endpoint/controller"
 
 class ApplicationController < ActionController::Base
-
+  def self.current_user_in_domain_ctx
+    ->(_ctx, ((ctx, a), b)) { ctx[:domain_ctx][:current_user] = ctx[:current_user]; [_ctx, [[ctx, a], b]] } # FIXME: extract to lib?
+  end
 end
 
 

data/test/rails-app/app/controllers/application_controller/api.rb

@@ -1,6 +1,8 @@
 #:app-controller
+#:app-include
 class ApplicationController::Api < ApplicationController
-  include Trailblazer::Endpoint::Controller.module(api: true)
+  include Trailblazer::Endpoint::Controller.module(api: true, application_controller: true)
+#:app-include end
 
   def self.options_for_block_options(ctx, controller:, **)
     response_block = ->(ctx, endpoint_ctx:, **) do

data/test/rails-app/app/controllers/application_controller/web.rb

@@ -1,30 +1,44 @@
+#:app-include
+#:options
+#:protocol
+#:generic
 class ApplicationController::Web < ApplicationController
-  extend Trailblazer::Endpoint::Controller
-  include Trailblazer::Endpoint::Controller::InstanceMethods::DSL
-  include Trailblazer::Endpoint::Controller::Rails
-  extend Trailblazer::Endpoint::Controller::Rails::DefaultBlocks
-  extend Trailblazer::Endpoint::Controller::Rails::DefaultParams
-  include Trailblazer::Endpoint::Controller::Rails::Process
+#~pskip
+#~gskip
+  include Trailblazer::Endpoint::Controller.module(dsl: true, application_controller: true)
+#:app-include end
 
-  # 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 self.options_for_endpoint(ctx, controller:, **)
+    {
+      session: controller.session,
+    }
+  end
 
-  Protocol = Class.new(Trailblazer::Endpoint::Protocol) do
-    # no {:seq} dependency
-    def authenticate(ctx, domain_ctx:, **)
-      # puts domain_ctx[:params].inspect
+  directive :options_for_endpoint, method(:options_for_endpoint)
+#:options end
 
-puts "TODO: should we always inject params into the endpoint_ctx?"
-      domain_ctx[:params][:authenticate] == "false" ? false : true
+  # directive :options_for_flow_options, method(:options_for_flow_options)
+  # directive :options_for_block_options, method(:options_for_block_options)
+#~pskip end
+  class Protocol < Trailblazer::Endpoint::Protocol
+    # provide method for {step :authenticate}
+    def authenticate(ctx, session:, **)
+      ctx[:current_user] = User.find_by(id: session[:user_id])
     end
 
+    # provide method for {step :policy}
     def policy(ctx, domain_ctx:, **)
-      domain_ctx[:params][:policy] == "false" ? false : true
+      Policy.(domain_ctx)
     end
   end
-
-  endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web do
-    {Output(:not_found) => Track(:not_found)}
-  end
+#:protocol end
+  Policy = ->(domain_ctx) { domain_ctx[:params][:policy] == "false" ? false : true }
+#~gskip end
+  endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web,
+    domain_ctx_filter: ApplicationController.current_user_in_domain_ctx
 end
+#:generic end
+
+# do
+#   {Output(:not_found) => Track(:not_found)}
+# end

data/test/rails-app/app/controllers/auth_controller.rb

@@ -0,0 +1,44 @@
+class AuthController < ApplicationController::Web
+  # We could use a fully-fledged operation here, with a contract and whatnot.
+  def self.authenticate(ctx, request:, params:, **)
+    if params[:username] == "yogi@trb.to" && params[:password] == "secret"
+      ctx[:current_user] = User.find_by(email: params[:username])
+
+      return true
+    else
+      return false # let's be extra explicit!
+    end
+  end
+
+  endpoint("sign_in", domain_activity: Class.new(Trailblazer::Activity::Railway)) do
+    # step nil, delete: :domain_activity
+    step nil, delete: :policy
+    step AuthController.method(:authenticate), replace: :authenticate, inherit: true, id: :authenticate
+
+    {}
+  end
+
+  def self.options_for_endpoint(ctx, controller:, **)
+    {
+      params: controller.params,
+      request: controller.request,
+    }
+  end
+
+  directive :options_for_endpoint, method(:options_for_endpoint)
+
+  def sign_in
+    endpoint "sign_in" do |ctx, current_user:, **|
+      session[:user_id] = current_user.id # Working on {session} is HTTP-specific and done in the controller.
+
+      redirect_to dashboard_path
+      # render html: "Yes!"
+    end
+  end
+
+private
+
+  def dashboard_path
+    "/"
+  end
+end

data/test/rails-app/app/controllers/home_controller.rb

@@ -0,0 +1,5 @@
+class HomeController < ApplicationController
+  def dashboard
+    render html: "Yo!"
+  end
+end

data/test/rails-app/app/controllers/songs_controller.rb

@@ -1,24 +1,84 @@
+#:endpoint
+#:or
+#:create
 class SongsController < ApplicationController::Web
-  endpoint("Create", domain_activity: Song::Operation::Create) do {} end # FIXME: we still need to provide an empty hash here if we want to override the not_found behavior.
+  endpoint Song::Operation::Create
 
-  # directive :options_for_domain_ctx, ->(ctx, **) { {seq: []} }
+#:endpoint end
+  def create
+    endpoint Song::Operation::Create do |ctx, current_user:, model:, **|
+      render html: cell(Song::Cell::Create, model, current_user: current_user)
+    end.Or do |ctx, contract:, **| # validation failure
+      render html: cell(Song::Cell::New, contract)
+    end
+  end
+#:create end
 
+#~oskip
+  class CreateOrController < SongsController
+#~oskip end
   def create
-    endpoint "Create"
+    endpoint Song::Operation::Create do |ctx, current_user:, model:, **|
+      render html: cell(Song::Cell::Create, model, current_user: current_user)
+    end.Or do |ctx, contract:, **| # validation failure
+      render json: contract.errors, status: 422
+    end
   end
+end
+#:or end
 
-  def create_with_options
-    endpoint "Create", process_model: "yay!" do |ctx, model:, endpoint_ctx:, **|
-      # TODO test process_model
-      render json: [model, endpoint_ctx[:process_model]]
+  def create_without_block
+    endpoint Song::Operation::Create
+  end
+
+  class CreateWithOptionsController < SongsController
+    #:create-options
+    def create
+      endpoint Song::Operation::Create, session: {user_id: 2} do |ctx, current_user:, model:, **|
+        render html: cell(Song::Cell::Create, model, current_user: current_user)
+      end
     end
+    #:create-options end
   end
 
-  def create_with_or
-    endpoint "Create" do |ctx, model:, **|
-      render json: {or: model}
-    end.Or do |ctx, model:, endpoint_ctx:, **|
-      render json: model, status: 422
+
+  class CreateWithOptionsForDomainCtxController < SongsController
+    #:domain_ctx
+    def create
+      endpoint Song::Operation::Create, options_for_domain_ctx: {params: {id: 999}} do |ctx, model:, **|
+        render html: cell(Song::Cell::Create, model)
+      end
     end
+    #:domain_ctx end
+  end
+
+  class CreateEndpointCtxController < SongsController
+    #:endpoint_ctx
+    def create
+      endpoint Song::Operation::Create do |ctx, endpoint_ctx:, **|
+        render html: "Created", status: endpoint_ctx[:status]
+      end.Or do |ctx, **| # validation failure
+        #~empty
+        #~empty end
+      end
+    end
+    #:endpoint_ctx end
+  end
+
+  # end.Or do |ctx, endpoint_ctx:, **| # validation failure
+  #       render json: endpoint_ctx.keys, status: 422
+  #     end
+
+
+  class CreateWithProtocolFailureController < SongsController
+  #:protocol_failure
+  def create_with_protocol_failure
+    endpoint Song::Operation::Create do |ctx, **|
+      redirect_to dashboard_path
+    end.protocol_failure do |ctx, **|
+      render html: "wrong login, app crashed", status: 500
+    end
+  end
+  #:protocol_failure end
   end
 end

data/test/rails-app/app/models/user.rb

@@ -1,5 +1,7 @@
 class User < Struct.new(:id, :email)
-  def self.find_by(id:)
+  def self.find_by(id: false, email: false)
+    return User.new(1, "yogi@trb.to") if email == "yogi@trb.to"
     return User.new(id, "yogi@trb.to") if id.to_s == "1"
+    return User.new(id, "seuros@trb.to") if id.to_s == "2"
   end
 end

data/test/rails-app/config/application.rb

@@ -33,6 +33,6 @@ module RailsApp
     # Only loads a smaller set of middleware suitable for API only apps.
     # Middleware like session, flash, cookies can be added back manually.
     # Skip views, helpers and assets when generating a new resource.
-    config.api_only = true
+    config.api_only = false
   end
 end

data/test/rails-app/config/routes.rb

@@ -1,11 +1,18 @@
 Rails.application.routes.draw do
   # For details on the DSL available within this file, see https://guides.rubyonrails.org/routing.html
-  resources :songs
-  post "/songs/create_with_options", to: "songs#create_with_options"
-  post "/songs/create_with_or", to: "songs#create_with_or"
+  post "/songs/create_with_options", to: "songs_controller/create_with_options#create"
+  post "/songs/create_or", to: "songs_controller/create_or#create"
+  post "/songs/endpoint_ctx", to: "songs_controller/create_endpoint_ctx#create"
+  post "/songs/create_with_or", to: "songs#create"
+  post "/songs", to: "songs#create_without_block"
+  post "/songs/create_with_protocol_failure", to: "songs_controller/create_with_protocol_failure#create_with_protocol_failure"
+  post "/songs/create_with_options_for_domain_ctx", to: "songs_controller/create_with_options_for_domain_ctx#create"
+  post "/auth/sign_in", to: "auth#sign_in"
 
   post "/v1/songs", to: "api/v1/songs#create"
   get "/v1/songs/:id", to: "api/v1/songs#show"
 
   get "/v1/songs_with_options/:id", to: "api/v1/songs_controller/with_options#show"
+
+  get "/", to: "home#dashboard"
 end

data/test/rails-app/test/controllers/api_songs_controller_test.rb

@@ -32,11 +32,13 @@ class ApiSongsControllerTest < ActionDispatch::IntegrationTest
   test "API interface" do
     yogi_jwt = jwt(1)
 
+  # default {success}
+    #:success
     post_json "/v1/songs", {id: 1}, yogi_jwt
 
-  # default {success}
     assert_response 200
     assert_equal "{\"id\":1}", response.body
+    #:success end
 
     # no proper input/params
     post_json "/v1/songs", {}, yogi_jwt
@@ -45,9 +47,11 @@ class ApiSongsControllerTest < ActionDispatch::IntegrationTest
     assert_equal "{\"errors\":{\"message\":\"The submitted data is invalid.\"}}", response.body
 
   # 401
-    post_json "/v1/songs", {authenticate: false}
+    #:not_authenticated
+    post_json "/v1/songs", {} # no token
     assert_response 401
     assert_equal "{\"errors\":{\"message\":\"Authentication credentials were not provided or are invalid.\"}}", response.body
+    #:not_authenticated end
 
   # 403
     post_json "/v1/songs", {id: 1, policy: false}, yogi_jwt

data/test/rails-app/test/controllers/songs_controller_test.rb

@@ -1,7 +1,18 @@
 require "test_helper"
 
 class SongsControllerTest < ActionDispatch::IntegrationTest
-  test "create 200" do
+  test "all possible outcomes with {Create}" do
+  # 401
+    post "/songs", params: {}
+    assert_response 401
+    assert_equal "", response.body
+
+  # sign in
+    post "/auth/sign_in", params: {username: "yogi@trb.to", password: "secret"}
+    assert_equal 1, session[:user_id]
+    # follow_redirect!
+    assert_equal 1, session[:user_id]
+
     post "/songs", params: {id: 1}
   # default {success} block doesn't do anything
     assert_response 200
@@ -12,11 +23,6 @@ class SongsControllerTest < ActionDispatch::IntegrationTest
     assert_response 422
     assert_equal "", response.body
 
-  # 401
-    post "/songs", params: {authenticate: false}
-    assert_response 401
-    assert_equal "", response.body
-
   # 403
     post "/songs", params: {policy: false}
     assert_response 403
@@ -25,7 +31,7 @@ class SongsControllerTest < ActionDispatch::IntegrationTest
     post "/songs/create_with_options", params: {id: 1}
   # {success} block renders model
     assert_response 200
-    assert_equal "[\"1\",\"yay!\"]", response.body
+    assert_equal "<div>#<struct Song id=\"1\">#<struct User id=2, email=\"seuros@trb.to\"></div>\n", response.body
 
     post "/songs/create_with_options", params: {}
   # default {failure} block doesn't do anything
@@ -35,13 +41,48 @@ class SongsControllerTest < ActionDispatch::IntegrationTest
     post "/songs/create_with_or", params: {id: 1}
   # {success} block renders model
     assert_response 200
-    assert_equal "{\"or\":\"1\"}", response.body
+    assert_equal "<div>#<struct Song id=\"1\">#<struct User id=1, email=\"yogi@trb.to\"></div>\n", response.body
 
     post "/songs/create_with_or", params: {}
-  # default {failure} block doesn't do anything
+    assert_response 200
+    assert_equal %{<div>#<struct errors=nil></div>\n}, response.body
+
+  # Or { render status: 422 }
+    post "/songs/create_or", params: {}
     assert_response 422
-    assert_equal "null", response.body
+    assert_equal %{null}, response.body
+
+  # {:endpoint_ctx} is available in blocks
+    post "/songs/endpoint_ctx", params: {id: 1}
+    assert_response 200
+    assert_equal "Created", response.body
+    # assert_equal "[\"domain_ctx\",\"session\",\"controller\",\"config_source\",\"current_user\",\"domain_activity_return_signal\"]", response.body
+
+    # {:options_for_domain_ctx} overrides domain_ctx
+    post "/songs/create_with_options_for_domain_ctx", params: {id: 1} # params get overridden
+    assert_response 200
+    assert_equal "<div>#<struct Song id=999></div>\n", response.body
+  end
+
+  test "override protocol_failure" do
+    post "/songs/create_with_protocol_failure", params: {}
+    assert_response 500
+    assert_equal "wrong login, app crashed", response.body
+  end
+
+  test "sign_in" do
+  # wrong credentials
+    post "/auth/sign_in", params: {}
+    assert_response 401
+    assert_equal "", response.body
+    assert_nil session[:user_id]
 
+  # valid signin
+    post "/auth/sign_in", params: {username: "yogi@trb.to", password: "secret"}
+    assert_response 302
+    # assert_equal "", response.body
+    assert_equal 1, session[:user_id]
+    assert_redirected_to "/"
   end
 end
 

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-endpoint
 version: !ruby/object:Gem::Version
-  version: 0.0.5
+  version: 0.0.6
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-09-09 00:00:00.000000000 Z
+date: 2020-11-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity-dsl-linear
@@ -129,13 +129,19 @@ files:
 - test/rails-app/app/concepts/auth/jwt.rb
 - test/rails-app/app/concepts/auth/operation/authenticate.rb
 - test/rails-app/app/concepts/auth/operation/policy.rb
+- test/rails-app/app/concepts/song/cell/create.rb
+- test/rails-app/app/concepts/song/cell/new.rb
 - test/rails-app/app/concepts/song/operation/create.rb
 - test/rails-app/app/concepts/song/operation/show.rb
 - test/rails-app/app/concepts/song/representer.rb
+- test/rails-app/app/concepts/song/view/create.erb
+- test/rails-app/app/concepts/song/view/new.erb
 - test/rails-app/app/controllers/api/v1/songs_controller.rb
 - test/rails-app/app/controllers/application_controller.rb
 - test/rails-app/app/controllers/application_controller/api.rb
 - test/rails-app/app/controllers/application_controller/web.rb
+- test/rails-app/app/controllers/auth_controller.rb
+- test/rails-app/app/controllers/home_controller.rb
 - test/rails-app/app/controllers/songs_controller.rb
 - test/rails-app/app/models/application_record.rb
 - test/rails-app/app/models/concerns/.keep
@@ -222,13 +228,19 @@ test_files:
 - test/rails-app/app/concepts/auth/jwt.rb
 - test/rails-app/app/concepts/auth/operation/authenticate.rb
 - test/rails-app/app/concepts/auth/operation/policy.rb
+- test/rails-app/app/concepts/song/cell/create.rb
+- test/rails-app/app/concepts/song/cell/new.rb
 - test/rails-app/app/concepts/song/operation/create.rb
 - test/rails-app/app/concepts/song/operation/show.rb
 - test/rails-app/app/concepts/song/representer.rb
+- test/rails-app/app/concepts/song/view/create.erb
+- test/rails-app/app/concepts/song/view/new.erb
 - test/rails-app/app/controllers/api/v1/songs_controller.rb
 - test/rails-app/app/controllers/application_controller.rb
 - test/rails-app/app/controllers/application_controller/api.rb
 - test/rails-app/app/controllers/application_controller/web.rb
+- test/rails-app/app/controllers/auth_controller.rb
+- test/rails-app/app/controllers/home_controller.rb
 - test/rails-app/app/controllers/songs_controller.rb
 - test/rails-app/app/models/application_record.rb
 - test/rails-app/app/models/concerns/.keep