trailblazer-endpoint 0.0.6 → 0.0.7

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4dd0d753bd8dc039e3f55e66d80d3d9d4904fcc0d442ea62860fbab4a0b05d5e
-  data.tar.gz: 0ecfa53ed1607d4d3785d47ffef3f817033b18ec29c6cbbf06e4f466c90a2638
+  metadata.gz: d241ba658c264d5ec48e241c59abe89811646109f07a1f900231d7963245bcad
+  data.tar.gz: '0682d8ad85197f3049c481f3868ae87982991c913ffd8e5f3ae8185b2554a274'
 SHA512:
-  metadata.gz: 7762ada8e3fafbd1a68e5f4045af8e57b03568745ac55236d756da6a4fe681f6818abd4e27b737b162872b9ebd4589f440b1b7ebee01729d2cfd6dd88702d980
-  data.tar.gz: 6f56d293369de1da783002e8d9f602f2847eafbe2f7ad80f5f6a08fc305542f3d432d7c9878376cc421a38de58e19d60eac2d436fe2650191b36f66d149bb722
+  metadata.gz: 0c7b9c72993a46d19c81307a94423e732b7eb0d433526cb9d32e9f7e70e54fa4eb36e3cf062eb3d77eebc9372955c8853ddbbb2b13ef9a22e711c0c7b09a9cad
+  data.tar.gz: ac107aae848481b55309b9c4fc607dd42c505fc16c1a267657cba4852660ecd72c8de4dcc9036b8a09bcf99d0d7d4c75d6fca9a956ba53562b8769f2913801a3

data/CHANGES.md

@@ -1,3 +1,9 @@
+# 0.0.7
+
+* BREAKING: Remove `:domain_ctx_filter` in favor of `Controller.insert_copy_to_domain_ctx!`.
+* Add support for serializing `:suspend_data` and deserializing `:resume_data` so session data can get automatically encrypted and passed to the next action. This used to sit in `workflow`.
+* Add `:find_process_model`. This introduces a new protocol step before `policy` to find the "process model" instead of letting the domain operation or even the policy (or both!) find the "current model".
+
 # 0.0.6
 
 * `Controller::endpoint` short form introduced.

data/lib/trailblazer/endpoint.rb

@@ -2,7 +2,12 @@ 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, protocol_block: ->(*) { Hash.new })
+    def self.build(protocol:, adapter:, domain_activity:, scope_domain_ctx: true, protocol_block: ->(*) { Hash.new },
+      serialize: false, # TODO: plug-in, not hardcoded!
+      deserialize: false,# TODO: plug-in, not hardcoded!
+      find_process_model: false, # TODO: plug-in, not hardcoded!
+      deserialize_process_model_id_from_resume_data: false # TODO: plug-in, not hardcoded!
+      )
       # special considerations around the {domain_activity} and its taskWrap:
       #
       #  1. domain_ctx_filter (e.g. to filter {current_user})
@@ -19,14 +24,41 @@ module Trailblazer
       # scoping: {:domain_ctx} becomes ctx
       extensions_options.merge!(Endpoint.options_for_scope_domain_ctx) if scope_domain_ctx # TODO: test flag
 
+      app_protocol = build_protocol(protocol, domain_activity: domain_activity, extensions_options: extensions_options, protocol_block: protocol_block, serialize: serialize, deserialize: deserialize,
+        find_process_model: find_process_model, deserialize_process_model_id_from_resume_data: deserialize_process_model_id_from_resume_data
+        )
+
+      # puts Trailblazer::Developer.render(app_protocol)
+
+      Class.new(adapter) do
+        step(Subprocess(app_protocol), {inherit: true, id: :protocol, replace: :protocol})
+      end # app_adapter
+
+    end
+
+    # @private
+    def self.build_protocol(protocol, domain_activity:, extensions_options:, protocol_block:, serialize:, deserialize:, find_process_model:, deserialize_process_model_id_from_resume_data:)
+      Class.new(protocol) do
+        if serialize
+          Protocol::Controller.insert_serialize_steps!(self)
+        end
+
+        if deserialize
+          Protocol::Controller.insert_deserialize_steps!(self)
+        end
+
+        if serialize || deserialize
+          Protocol::Controller.insert_copy_to_domain_ctx!(self, :resume_data => :resume_data)
+        end
 
-      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
+        if find_process_model
+          Protocol::Controller.insert_find_process_model!(self, before: :policy) # TODO: test before: :policy
+        end
 
-      # puts Trailblazer::Developer.render(protocol)
-      # puts
+        if deserialize_process_model_id_from_resume_data
+          pass Protocol::Controller.method(:deserialize_process_model_id_from_resume_data), after: :deserialize_resume_data, magnetic_to: :deserialize, Output(:success) => Track(:deserialize)
+        end
 
-      app_protocol = Class.new(protocol) do
         step(Subprocess(domain_activity), {inherit: true, id: :domain_activity, replace: :domain_activity,
 
 # FIXME: where does this go?
@@ -35,13 +67,6 @@ module Trailblazer
           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
-
     end
 
     def self.options_for_scope_domain_ctx()
@@ -51,16 +76,6 @@ 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::Activity::TaskWrap.method(:invoke))
@@ -146,3 +161,6 @@ require "trailblazer/endpoint/adapter"
 require "trailblazer/endpoint/dsl"
 require "trailblazer/endpoint/controller"
 require "trailblazer/endpoint/options"
+require "trailblazer/endpoint/protocol/controller"
+require "trailblazer/endpoint/protocol/find_process_model"
+require "trailblazer/endpoint/protocol/cipher"

data/lib/trailblazer/endpoint/controller.rb

@@ -92,18 +92,18 @@ module Trailblazer
             extended.directive(:endpoints, ->(*) { {} })
           end
 
+          # Builds and registers an endpoint in a controller class.
           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)
+            build_endpoint(name, **options)
           end
 
-          def generic_endpoint_config(protocol:, adapter:, **options)
+          # Configures generic {:adapter}, {:protocol}, etc.
+          def generic_endpoint_config(**options)
             self.singleton_class.define_method :generic_options do |ctx,**|
               {
-                protocol: protocol,
-                adapter: adapter,
                 **options
               }
             end
@@ -111,7 +111,7 @@ module Trailblazer
             directive :generic_options, method(:generic_options) # FIXME: do we need this?
           end
 
-          def endpoint_config(name, domain_activity: name, **options)
+          def build_endpoint(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)

data/lib/trailblazer/endpoint/dsl.rb

@@ -19,9 +19,11 @@ module Trailblazer
         # #call
         def to_args(default_block_options)
           return options,
+          default_block_options.merge( # this adds :invoke.
             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

data/lib/trailblazer/endpoint/protocol.rb

@@ -24,7 +24,7 @@ module Trailblazer
 
       step :authenticate, Output(:failure) => _Path(semantic: :not_authenticated) do
           # step :handle_not_authenticated
-        end
+      end
 
       step :policy, Output(:failure) => _Path(semantic: :not_authorized) do # user from cookie, etc
         # step :handle_not_authorized
@@ -113,7 +113,6 @@ module Trailblazer
           [[Trailblazer::Activity::TaskWrap::Pipeline.method(:insert_after), "task_wrap.call_task", ["endpoint.end_signal", method(:terminus_handler)]]]
         end
       end
-
-    end
+    end # Protocol
   end
 end

data/lib/trailblazer/endpoint/protocol/cipher.rb

@@ -0,0 +1,27 @@
+require "openssl"
+
+module Trailblazer
+  class Endpoint::Protocol
+    module Controller
+      module Cipher # FIXME: copied from Tyrant!
+        module_function
+
+        def encrypt_value(ctx, value:, cipher_key:, **)
+          cipher = OpenSSL::Cipher.new('DES-EDE3-CBC').encrypt
+          cipher.key = Digest::SHA1.hexdigest(cipher_key)[0..23] # ArgumentError: key must be 24 bytes
+          s = cipher.update(value) + cipher.final
+
+          ctx[:encrypted_value] = s.unpack('H*')[0].upcase
+        end
+
+        def decrypt_value(ctx, encrypted_value:, cipher_key:, **)
+          cipher = OpenSSL::Cipher.new('DES-EDE3-CBC').decrypt
+          cipher.key = Digest::SHA1.hexdigest(cipher_key)[0..23]
+          s = [encrypted_value].pack("H*").unpack("C*").pack("c*")
+
+          ctx[:decrypted_value] = cipher.update(s) + cipher.final
+        end
+      end # Cipher
+    end
+  end
+end

data/lib/trailblazer/endpoint/protocol/controller.rb

@@ -0,0 +1,93 @@
+module Trailblazer
+  class Endpoint::Protocol
+    # Deserialize incoming state.
+    # Serialize outgoing state.
+    # What else?
+    module Controller
+      module_function
+
+      def decrypt?(ctx, encrypted_resume_data:, **)
+        encrypted_resume_data
+      end
+
+      def deserialize_resume_data(ctx, decrypted_value:, **)
+        ctx[:resume_data] = JSON.parse(decrypted_value)
+      end
+
+      def deserialize_process_model?(ctx, process_model_from_resume_data:, **)
+        process_model_from_resume_data
+      end
+
+      def deserialize_process_model_id(ctx, resume_data:, **)
+        ctx[:process_model_id] = resume_data["id"] # DISCUSS: overriding {:process_model_id}?
+      end
+
+      def encrypt?(ctx, domain_ctx:, **)
+        ctx[:suspend_data] = domain_ctx[:suspend_data]
+      end
+
+      def serialize_suspend_data(ctx, suspend_data:, **)
+        ctx[:serialized_suspend_data] = JSON.dump(suspend_data)
+      end
+
+      def copy_suspend_data_to_endpoint_ctx(ctx, domain_ctx:, **)
+        ctx[:suspend_data] = domain_ctx[:suspend_data]
+      end
+
+# FIXME: use Model() mechanics.
+      def deserialize_process_model_id_from_resume_data(ctx, resume_data:, **)
+        # DISCUSS: should we warn when overriding an existing {process_model_id}?
+        ctx[:process_model_id] = resume_data["id"] # DISCUSS: overriding {:process_model_id}? # FIXME: stolen from Advance___::Controller
+      end
+
+      def insert_deserialize_steps!(activity, deserialize_before: :policy)
+        activity.module_eval do
+          step Controller.method(:decrypt?), id: :decrypt?, before: deserialize_before # error out if no serialized_resume_data given.
+          step Controller::Cipher.method(:decrypt_value), id: :decrypt,
+              input: {cipher_key: :cipher_key, encrypted_resume_data: :encrypted_value}    , before: deserialize_before,
+              # Output(:failure) => Track(:success),
+              Output(:success) => Path(connect_to: Track(:success), track_color: :deserialize, before: deserialize_before) do # usually, Path goes into {policy}
+
+            step Controller.method(:deserialize_resume_data), id: :deserialize_resume_data
+            # DISCUSS: unmarshall?
+            # step Controller.method(:deserialize_process_model_id?), id: :deserialize_process_model_id?, activity.Output(Trailblazer::Activity::Left, :failure) => activity.Id(around_activity_id)
+            # step Controller.method(:deserialize_process_model_id), id: :deserialize_process_model_id
+
+            step ->(*) { true } # FIXME: otherwise we can't insert an element AFTER :deserialize_resume_data
+          end
+        end
+      end
+
+      def insert_serialize_steps!(activity, serialize_after: :domain_activity)
+        activity.module_eval do
+            # FIXME: reverse order for insertion
+          step Controller::Cipher.method(:encrypt_value), id: :encrypt                                                , after: serialize_after,
+              input: {cipher_key: :cipher_key, serialized_suspend_data: :value}, output: {encrypted_value: :encrypted_suspend_data}
+          step Controller.method(:serialize_suspend_data), id: :serialize_suspend_data                                , after: serialize_after
+          pass Controller.method(:copy_suspend_data_to_endpoint_ctx), id: :copy_suspend_data_to_endpoint_ctx          , after: serialize_after
+        end
+      end
+
+      # Insert the "experimental" {find_process_model} steps
+      def insert_find_process_model!(protocol, **options)
+        protocol.module_eval do
+          step Subprocess(FindProcessModel), Output(:failure) => End(:not_found),
+          id: :find_process_model,
+          **options
+            # after: :authenticate
+        end
+
+        insert_copy_to_domain_ctx!(protocol, :process_model => :model)
+      end
+
+      def insert_copy_to_domain_ctx!(protocol, variables)
+        variables.each do |original_name, domain_name|
+          protocol.module_eval do
+            pass ->(ctx, domain_ctx:, **) { domain_ctx[domain_name] = ctx[original_name] if ctx.key?(original_name) },
+              id: :"copy_[#{original_name.inspect}]_to_domain_ctx[#{domain_name.inspect}]", before: :domain_activity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/trailblazer/endpoint/protocol/find_process_model.rb

@@ -0,0 +1,15 @@
+class Trailblazer::Endpoint::Protocol
+  class FindProcessModel < Trailblazer::Activity::Railway
+    # step :find_process_model?, Output(:failure) => Id("End.success")
+    step :find_process_model#,  Output(:failure) => End(:not_found) # DISCUSS: currently, {End.failure} implies {not_found}.
+
+    # DISCUSS: should the implementation   remain in {Activity}?
+    # def find_process_model?(ctx, find_process_model:, **)
+    #   find_process_model
+    # end
+
+    def find_process_model(ctx, process_model_class:, process_model_id:, **)
+      ctx[:process_model] = process_model_class.find_by(id: process_model_id)
+    end
+  end
+end

data/lib/trailblazer/endpoint/version.rb

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

data/test/docs/controller_test.rb

@@ -58,7 +58,8 @@ class DocsControllerTest < Minitest::Spec
       include T.def_steps(:authenticate, :policy)
     end
 
-    endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web, domain_ctx_filter: Trailblazer::Endpoint.domain_ctx_filter([:current_user, :process_model]), scope_domain_ctx: true
+    endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web,
+    scope_domain_ctx: true
   end
 
   class HtmlController < ApplicationController

data/test/rails-app/Gemfile

@@ -21,3 +21,9 @@ gem "minitest-line"
 gem "trailblazer-cells"
 gem "cells-erb"
 gem "cells-rails"
+
+
+# FIXME
+gem "trailblazer-workflow", path: "../../../trailblazer-workflow"
+# gem "trailblazer-activity-dsl-linear", path: "../../../trailblazer-activity-dsl-linear"
+gem "trailblazer-activity-dsl-linear", ">= 0.3.4"

data/test/rails-app/Gemfile.lock

@@ -1,8 +1,17 @@
+PATH
+  remote: ../../../trailblazer-workflow
+  specs:
+    trailblazer-workflow (0.0.8)
+      trailblazer-activity
+      trailblazer-activity-implementation
+      trailblazer-developer (>= 0.0.10)
+      trailblazer-endpoint
+
 PATH
   remote: ../..
   specs:
-    trailblazer-endpoint (0.0.5)
-      trailblazer-activity-dsl-linear (>= 0.3.0, < 0.4.0)
+    trailblazer-endpoint (0.0.7)
+      trailblazer-activity-dsl-linear (>= 0.3.4, < 0.4.0)
 
 GEM
   remote: https://rubygems.org/
@@ -156,8 +165,11 @@ GEM
     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-activity-dsl-linear (0.3.4)
+      trailblazer-activity (>= 0.11.3, < 1.0.0)
+    trailblazer-activity-implementation (0.0.3)
+      trailblazer-activity (>= 0.8.0)
+      trailblazer-activity-dsl-linear
     trailblazer-cells (0.0.3)
       cells (>= 4.1.0.rc1, < 5.0.0)
     trailblazer-context (0.3.1)
@@ -190,9 +202,11 @@ DEPENDENCIES
   multi_json
   rails (~> 6.0.3, >= 6.0.3.1)
   sqlite3 (~> 1.4)
+  trailblazer-activity-dsl-linear (>= 0.3.4)
   trailblazer-cells
   trailblazer-endpoint!
   trailblazer-operation
+  trailblazer-workflow!
 
 BUNDLED WITH
    2.1.4

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

@@ -30,12 +30,13 @@ class ApplicationController::Web < ApplicationController
     def policy(ctx, domain_ctx:, **)
       Policy.(domain_ctx)
     end
+
+    Trailblazer::Endpoint::Protocol::Controller.insert_copy_to_domain_ctx!(self, :current_user => :current_user)
   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
+  endpoint protocol: Protocol, adapter: Trailblazer::Endpoint::Adapter::Web
 end
 #:generic end
 

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

@@ -81,4 +81,178 @@ end
   end
   #:protocol_failure end
   end
+
+
+  # endpoint_ctx
+  #   :resume_data
+  #   domain_ctx
+  #     :resume_data (copy)
+
+
+  # authenticate
+
+  # deserialize ==> {resume_data: {id: 1}}
+  # deserialize_process_model_id_from_resume_data
+
+  # find_process_model
+  # policy
+  # domain_activity
+
+  # serialize suspend_data and deserialize resume_data
+  class SerializeController < SongsController
+    endpoint Song::Operation::Create,
+      protocol: ApplicationController::Web::Protocol
+            # serialize: true
+
+    def self.options_for_block_options(ctx, **)
+      {
+        invoke: Trailblazer::Developer.method(:wtf?) # FIXME
+      }
+    end
+
+
+    def self.options_for_endpoint(ctx, controller:, **)
+      {
+        cipher_key: Rails.application.config.cipher_key,
+
+        encrypted_resume_data: controller.params[:encrypted_resume_data],
+      }
+    end
+
+    directive :options_for_block_options, method(:options_for_block_options)
+    directive :options_for_endpoint, method(:options_for_endpoint)
+
+    def create
+      encrypted_value = Trailblazer::Workflow::Cipher.encrypt_value({}, cipher_key: cipher_key, value: JSON.dump({id: "findings received", class: Object}))
+
+      endpoint Song::Operation::Create, encrypted_resume_data: encrypted_value, process_model_from_resume_data: false do |ctx, current_user:, endpoint_ctx:, **|
+        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
+  end
+
+  # TODO: not really a doc test.
+# the entire deserialize cycle is skipped since we only use {:serialize}
+  class Serialize1Controller < SerializeController
+    class Create < Trailblazer::Operation
+      pass ->(ctx, **) { ctx[:model] = ctx.key?(:model) ? ctx[:model] : false }
+    end
+
+    endpoint "Create",
+      domain_activity: Create,
+      serialize: true,
+      deserialize: true
+
+    def create
+      # {:model} and {:memory} are from the domain_ctx.
+      # {:encrypted_suspend_data} from endpoint.
+      endpoint "Create" do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{ctx[:memory].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end.Or do |ctx, **| # validation failure
+        render html: "xxx", status: 500
+      end
+    end
+  end
+
+    # TODO: not really a doc test.
+# ---------deserialize cycle is skipped.
+# we serialize {:remember}.
+  class Serialize2Controller < Serialize1Controller # "render confirm page"
+    class Create < Trailblazer::Operation
+      pass ->(ctx, **) { ctx[:model] = ctx.key?(:model) ? ctx[:model] : false }
+      step ->(ctx, **) { ctx[:suspend_data] = {remember: OpenStruct.new(id: 1), id: 9} }   # write to domain_ctx[:suspend_data]
+    end
+
+    endpoint "Create",
+      domain_activity: Create,
+      serialize: true
+  end
+
+  # we can read from {:resume_data}
+  class Serialize3Controller < Serialize1Controller # "process submitted confirm page"
+    class Create < Trailblazer::Operation
+      pass ->(ctx, **) { ctx[:model] = ctx.key?(:model) ? ctx[:model] : false }
+      pass ->(ctx, **) { ctx[:memory] = ctx[:resume_data] }                           # read/process the suspended data
+    end
+
+    endpoint "Create",
+      domain_activity: Create,
+      deserialize: true
+  end
+
+# find process_model via id in suspend/resume data (used to be called {process_model_from_resume_data})
+  class Serialize4Controller < Serialize1Controller
+    class Create < Trailblazer::Operation
+      pass ->(ctx, **) { ctx[:model] = ctx.key?(:model) ? ctx[:model] : false }
+      pass ->(ctx, **) { ctx[:memory] = ctx[:resume_data] }                           # read/process the suspended data
+    end
+
+    endpoint "Create",
+      domain_activity: Create,
+      deserialize: true,
+      find_process_model: true,
+      deserialize_process_model_id_from_resume_data: true
+
+    def create
+      endpoint "Create", process_model_class: Song do |ctx, endpoint_ctx:, **|
+        render html: "#{endpoint_ctx[:process_model_id].inspect}/#{ctx[:memory].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
+    end
+  end
+
+  # find process_model from resume
+  # FIXME: what is the diff to Controller4?
+  class Serialize5Controller < Serialize1Controller
+    endpoint "Create",
+      domain_activity: Serialize4Controller::Create,
+      deserialize: true,
+      find_process_model: true,
+      deserialize_process_model_id_from_resume_data: true
+
+    def create
+      endpoint "Create", find_process_model: true, process_model_class: Song, process_model_id: params[:id] do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{ctx[:memory].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
+    end
+  end
+
+  # find process_model from action_options
+  class Serialize6Controller < Serialize1Controller
+    endpoint "Create",
+      domain_activity: Serialize4Controller::Create,
+      protocol: ApplicationController::Web::Protocol,
+      find_process_model: true
+
+    def create
+      endpoint "Create", find_process_model: true, process_model_class: Song, process_model_id: params[:id] do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{endpoint_ctx[:process_model].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
+    end
+  end
+
+# Configure only {:find_process_model} and {:protocol}.
+  class Serialize7Controller < Serialize1Controller
+    endpoint find_process_model: true # generic setting for all endpoints in this controller.
+
+    endpoint "Create", # no need to specify {:find_process_model}
+      domain_activity: Serialize4Controller::Create
+
+    endpoint "New",
+      find_process_model: false,
+      domain_activity: Serialize4Controller::Create
+
+    def create
+      endpoint "Create", process_model_class: Song, process_model_id: params[:id] do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{endpoint_ctx[:process_model].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
+    end
+
+    def new
+      endpoint "New", process_model_class: Song, process_model_id: params[:id] do |ctx, model:, endpoint_ctx:, **|
+        render html: "#{model.inspect}/#{endpoint_ctx[:process_model].inspect}/#{endpoint_ctx[:encrypted_suspend_data]}".html_safe
+      end
+    end
+  end
 end

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

@@ -1,3 +1,6 @@
 class Song < Struct.new(:id)
-
+  def self.find_by(id: false)
+    return unless id
+    return Song.new(id)
+  end
 end

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

@@ -35,4 +35,6 @@ Rails.application.configure do
 
   # Raises error for missing translations.
   # config.action_view.raise_on_missing_translations = true
+
+  config.cipher_key = "e1e1cc87asdfasdfasdfasfdasdfasdfasvhnfvbdb" # FIXME: this usually happens via the new key mechanism in Rails 6
 end

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

@@ -15,4 +15,14 @@ Rails.application.routes.draw do
   get "/v1/songs_with_options/:id", to: "api/v1/songs_controller/with_options#show"
 
   get "/", to: "home#dashboard"
+
+  post "/songs/serialize", to: "songs_controller/serialize#create"
+  post "/songs/serialize1", to: "songs_controller/serialize1#create"
+  post "/songs/serialize2", to: "songs_controller/serialize2#create"
+  post "/songs/serialize3", to: "songs_controller/serialize3#create"
+  post "/songs/serialize4", to: "songs_controller/serialize4#create"
+  post "/songs/serialize5", to: "songs_controller/serialize5#create"
+  post "/songs/serialize6", to: "songs_controller/serialize6#create"
+  post "/songs/serialize7", to: "songs_controller/serialize7#create"
+  post "/songs/serialize72", to: "songs_controller/serialize7#new"
 end

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

@@ -70,6 +70,75 @@ class SongsControllerTest < ActionDispatch::IntegrationTest
     assert_equal "wrong login, app crashed", response.body
   end
 
+  test "serializing/deserializing/find_process_model_from_resume_data" do
+  # # 401
+  #   post "/songs/serialize/"
+  #   assert_response 401
+
+  # sign in
+    post "/auth/sign_in", params: {username: "yogi@trb.to", password: "secret"}
+    assert_equal 1, session[:user_id]
+
+
+  # When {:encrypted_resume_data} is {nil} the entire deserialize cycle is skipped.
+  # Nothing gets serialized.
+  # This is considered an error since we're expecting resume data.
+    post "/songs/serialize1/", params: {} # encrypted_resume_data: nil
+    assert_response 500
+    assert_equal "xxx", response.body # DISCUSS: is this an application or a protocol error?
+
+  # Nothing deserialized, but {:remember} serialized
+  # "confirm_delete form"
+    post "/songs/serialize2/", params: {} # {:remember} serialized
+    assert_response 200
+    encrypted_string = "0109C4E535EDA2CCE8CD69E50C179F5950CC4A2A898504F951C995B6BCEAFE1DFAB02894854B96B9D11C23E25DB5FB03"
+    assert_equal "false/nil/#{encrypted_string}", response.body
+
+  # {:remember} deserialized
+  # "submit confirm_delete"
+  # We're expecting serialized data and don't serialize anything.
+    post "/songs/serialize3/", params: {encrypted_resume_data: encrypted_string} # {:remember} serialized
+    assert_response 200
+    assert_equal "false/{\"remember\"=>\"#<OpenStruct id=1>\", \"id\"=>9}/", response.body
+
+  # retrieve process_model via id in {:resume_data}
+  # we can see {endpoint_ctx[:process_model_id]}
+  # We're expecting serialized data and don't serialize anything.
+    post "/songs/serialize4/", params: {encrypted_resume_data: encrypted_string}
+    assert_response 200
+    assert_equal "9/{\"remember\"=>\"#<OpenStruct id=1>\", \"id\"=>9}/", response.body
+
+  # retrieve process_model via {:resume_data}'s serialized id.
+  # We're expecting serialized data and don't serialize anything.
+    post "/songs/serialize5/", params: {encrypted_resume_data: encrypted_string}
+    assert_response 200
+    assert_equal "#<struct Song id=9>/{\"remember\"=>\"#<OpenStruct id=1>\", \"id\"=>9}/", response.body
+    # model not found
+    post "/songs/serialize5/", params: {encrypted_resume_data: "36C61CCE30E6CFDE637DF0DA9257CC49"}
+    assert_response 404
+    assert_equal "", response.body
+
+  # find model without serialize from params, no serialized stuff passed
+  # DISCUSS: this could be a different test
+    post "/songs/serialize6/", params: {id: 1}
+    assert_response 200
+    assert_equal "#<struct Song id=\"1\">/#<struct Song id=\"1\">/", response.body
+    # model not found
+    post "/songs/serialize6/", params: {id: nil}
+    assert_response 404
+    assert_equal "", response.body
+
+  # {find_process_model: true} set on controller level, for all endpoints.
+    post "/songs/serialize7/", params: {id: 1}
+    assert_response 200
+    assert_equal "#<struct Song id=\"1\">/#<struct Song id=\"1\">/", response.body
+  # {find_process_model: false} overrides controller setting
+    post "/songs/serialize72/", params: {id: 1}
+    assert_response 200
+    assert_equal "false/nil/", response.body
+
+  end
+
   test "sign_in" do
   # wrong credentials
     post "/auth/sign_in", params: {}

data/trailblazer-endpoint.gemspec

@@ -17,7 +17,7 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.3.0", "< 0.4.0"
+  spec.add_dependency "trailblazer-activity-dsl-linear", ">= 0.3.4", "< 0.4.0"
 
   spec.add_development_dependency "bundler"
   spec.add_development_dependency "rake"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-endpoint
 version: !ruby/object:Gem::Version
-  version: 0.0.6
+  version: 0.0.7
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-11-17 00:00:00.000000000 Z
+date: 2020-12-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: trailblazer-activity-dsl-linear
@@ -16,7 +16,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.3.4
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.4.0
@@ -26,7 +26,7 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: 0.3.0
+        version: 0.3.4
     - - "<"
       - !ruby/object:Gem::Version
         version: 0.4.0
@@ -109,6 +109,9 @@ files:
 - lib/trailblazer/endpoint/dsl.rb
 - lib/trailblazer/endpoint/options.rb
 - lib/trailblazer/endpoint/protocol.rb
+- lib/trailblazer/endpoint/protocol/cipher.rb
+- lib/trailblazer/endpoint/protocol/controller.rb
+- lib/trailblazer/endpoint/protocol/find_process_model.rb
 - lib/trailblazer/endpoint/rails.rb
 - lib/trailblazer/endpoint/version.rb
 - test/adapter/api_test.rb