trailblazer-pro 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f87a1d9c0c7d557676ed48a4c3bab753f618b2593e018bcf9aeca16560257a26
-  data.tar.gz: 6a97c8a6ff18033972a4113e5d794ff399cb2f64dc81dc8df8a3f76361cffcfc
+  metadata.gz: 6abc91ad413fd17c14fb3a1c665b9c1cc73701fd7ad41f82ef973dd726102349
+  data.tar.gz: c5407c726b22a5f74462c7847c4e454176f0a3e1596215e5555c17415051261b
 SHA512:
-  metadata.gz: 4a2dc896a3d018eb93620f22e8ea5e528e2f6c737ede31612bf6ecd0f55824c863a99b30de790579b9d768988c693af0bf5b90eb5647e8e76c9cabd354c58fad
-  data.tar.gz: 30eb6636827c3070582f1b26a145c1b98a1d6fda95f19eba9565c6e95fe68492ab483eca897af37337b965fe8bf5899cd89d3fa4761ae80aa1c0919dc85ba7ff
+  metadata.gz: 3b2837a745201f9cd075a38fd0dcbb3601301f98ff5b37a60827981d0ea88bdcc4894399c9a30210bb9b857fe6e422d1ae209323faf4a5300e1a27917712ebdb
+  data.tar.gz: dce8f6060c62fcc657440d334397e1406c8ac9116a5bc9f78ff5b344423bf023adda62e28b8191a68b20cd5a0b867d86f7257a395d41807e351e9047e4060552

data/.github/workflows/main.yml

@@ -16,3 +16,5 @@ jobs:
         gem install bundler -v 2.2.11
         bundle install
         bundle exec rake
+        bundle exec rake test_1
+        bundle exec rake test_2

data/CHANGELOG.md

@@ -1,4 +1,6 @@
-## [Unreleased]
+## [0.0.2]
+
+- First real release!
 
 ## [0.0.1]
 

data/Gemfile

@@ -8,6 +8,12 @@ gemspec
 gem "rake", "~> 13.0"
 
 gem "minitest", "~> 5.0"
-
-# gem "faraday"
+# gem "trailblazer-developer", path: "../trailblazer-developer"
+gem "faraday"
 # gem "multi_json"
+# gem "trailblazer-macro", path: "../trailblazer-macro"
+# gem "trailblazer-activity", path: "../trailblazer-activity"
+# gem "trailblazer-activity", github: "trailblazer/trailblazer-activity"
+# gem "trailblazer-developer", path: "../trailblazer-developer"
+# gem "trailblazer-operation", path: "../trailblazer-operation"
+# gem "trailblazer-operation"

data/README.md

@@ -1,35 +1,36 @@
 # Trailblazer::Pro
 
-Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/trailblazer/pro`. To experiment with that code, run `bin/console` for an interactive prompt.
+A library to communicate with the TRAILBLAZER PRO platform.
 
-TODO: Delete this and the text above, and describe your gem
+* Push local traces to us, and analyze using the online debugger.
+* Export diagrams from the PRO editor to use with the `trailblazer-workflow` gem.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'trailblazer-pro'
+gem "trailblazer-pro"
 ```
 
-And then execute:
+## Rails support
 
-    $ bundle install
+Check out the [Rails support docs](https://trailblazer.to/2.1/docs/pro) of `trailblazer-pro-rails` if you want to start web-debugging right away.
 
-Or install it yourself as:
+## Trace
 
-    $ gem install trailblazer-pro
+Retrieve you API key from https://pro.trailblazer.to/settings.
+It will be something like `tpka_f5c698e2_d1ac_48fa_b59f_70e9ab100604`.
 
-## Usage
+## Internals
 
-TODO: Write usage instructions here
+### Testing
 
-## Development
+Either run against our hosted https://test-pro-rails-jwt.onrender.com TRB PRO host, or locally. This is currently set in `test/test_helper.rb`.
 
-After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake test` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
 
-To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and the created tag, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+* `test/no_extend` Tests an environment where no monkey-patches happened, and if, only on anonymous classes.
 
-## Contributing
+### Notes
 
-Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/trailblazer-pro.
+* With `endpoint`, monkey-patching might become obsolete, since we can inject {:present_options} transparently.

data/Rakefile

@@ -6,7 +6,19 @@ require "rake/testtask"
 Rake::TestTask.new(:test) do |t|
   t.libs << "test"
   t.libs << "lib"
-  t.test_files = FileList["test/**/*_test.rb"]
+  t.test_files = FileList["test/**/*_test.rb"] - FileList["test/global_extend/*"]
 end
 
 task default: :test
+
+Rake::TestTask.new(:test_1) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/global_extend/activity_call_test.rb"]
+end
+
+Rake::TestTask.new(:test_2) do |t|
+  t.libs << "test"
+  t.libs << "lib"
+  t.test_files = FileList["test/global_extend/integration_test.rb"]
+end

data/lib/trailblazer/pro/call/activity.rb

@@ -0,0 +1,20 @@
+module Trailblazer
+  module Pro
+    module Call
+      module Activity
+        # This is the monkey-patch for {Activity.call}.
+        # Here we decide whether to use tracing, and what to render,
+        # or if we should bypass tracing.
+        def call(activity, ctx)
+          trace_strategy, present_options_merge = Pro::Session.trace_guards.(activity, ctx)
+
+          if trace_strategy
+            return trace_strategy.invoke(activity, [ctx, {}], present_options: present_options_merge)
+          else
+            return super
+          end
+        end
+      end # Activity
+    end
+  end
+end

data/lib/trailblazer/pro/debugger.rb

@@ -0,0 +1,124 @@
+module Trailblazer
+  module Pro
+    module Debugger
+      module_function
+
+      # Called in {Trace::Present.call} as {:render_method}.
+      def call(debugger_trace:, activity:, render_wtf: false, renderer:, **options)
+        trace_data = render_trace_data(debugger_trace, activity: activity, **options)
+
+        trace_envelope = {
+          fields: {
+            activity_name:   {stringValue: activity},
+            trace:  {stringValue: trace_data},
+            created_at: {timestampValue: DateTime.now}, # we're using local client time currently.
+          }
+        }
+
+        session, stored_trace_id, session_updated = push(trace_envelope, activity: activity, **options)
+
+        debugger_url = "https://ide.trailblazer.to/#{stored_trace_id}"
+        # output       = "[TRB PRO] view trace (#{activity}) at #{debugger_url}"
+        # output       = Developer::Wtf::Renderer::String.bold(output)
+        output       = Developer::Wtf::Renderer::String.bold("[TRB PRO] view trace (#{activity}) at ")
+        output += debugger_url # DISCUSS: what do we want bold here?
+
+        if render_wtf
+          # TODO: take the color_map from outside caller.
+          wtf_output = Developer::Trace::Present.render(debugger_trace: debugger_trace, renderer: renderer, color_map: Developer::Wtf::Renderer::DEFAULT_COLOR_MAP) # , activity: activity
+
+          output = [wtf_output, output].join("\n")
+        end
+
+        returned_values = [session, stored_trace_id, debugger_url, trace_envelope, session_updated]
+
+        return output, returned_values
+      end
+
+      def render_trace_data(debugger_trace, activity:, **)
+        flat_tree_json = debugger_trace.to_a.collect do |debugger_node|
+
+          # TODO: do we even need to grab tw by path here?
+          introspect_nodes_node = OpenStruct.new(task: debugger_node.task)
+          tw_render = Developer::Render::TaskWrap.render_for(debugger_node.activity, introspect_nodes_node)
+
+          # This rendering code has deep knowledge of Trace/pro/v1 tracing interface.
+          {
+            id:             debugger_node.id.to_s,
+            runtime_id:     debugger_node.runtime_id,
+            level:          debugger_node.level,
+            label:          debugger_node.label,
+            ctx_snapshots: {
+              before: debugger_node.snapshot_before.data[:ctx_variable_changeset].collect { |name, hash, has_changed| [name, {version: hash.to_s, has_changed: !!has_changed}] },
+              after:  debugger_node.snapshot_after ?
+
+              debugger_node.snapshot_after.data[:ctx_variable_changeset].collect { |name, hash, has_changed| [name, {version: hash.to_s, has_changed: !!has_changed}] } # FIXME: of course, this is horrible.
+              : [],
+            },
+
+            rendered_task_wrap: tw_render,
+          }
+        end
+
+        JSON.dump(
+          nodes:              flat_tree_json,
+          variable_versions:  debugger_trace.to_h[:variable_versions].to_h,
+          pro_version: Pro::VERSION.to_s,
+        )
+      end
+
+      class Push < Trailblazer::Activity::Railway
+        step :session_initialized?,
+          Output(:failure) => Path(track_color: :signin, connect_to: Track(:rebuild)) do # FIXME: move to after {valid?}
+            # Signin only consumes {:api_key} and friends and doesn't know about {:session}.
+            step Subprocess(Trailblazer::Pro::Trace::Signin),
+              In() => :session_to_args#,
+              # Out() => Trace::Signin::SESSION_VARIABLE_NAMES
+          end
+
+        step Trace.method(:valid?), In() => :session_to_args, Inject() => [:now],
+          Output(:failure) => Path(track_color: :refresh, connect_to: Track(:rebuild)) do
+            step Subprocess(Trailblazer::Pro::Trace::Refresh), In() => :session_to_args
+          end
+
+        step :rebuild_session, magnetic_to: :rebuild # TODO: assert that success/failure go to right Track.
+
+        step Subprocess(Trailblazer::Pro::Trace::Store),
+          In() => :session_to_args,
+          In() => [:data_to_store]
+
+        def session_initialized?(ctx, session:, **)
+          session.is_a?(Session)
+        end
+
+        def rebuild_session(ctx, session:, **)
+          session_params = ctx.to_h.slice(*Trace::Signin::SESSION_VARIABLE_NAMES)
+
+          session = Session.new(
+            **session.to_h,  # old data
+            **session_params, # new input
+          )
+
+          ctx[:session] = session
+          ctx[:session_updated] = true
+        end
+
+        def session_to_args(ctx, session:, **)
+          session.to_h
+        end
+      end # Push
+
+      def push(trace_data, activity:, now: DateTime.now, **options)
+        # signal, (ctx, _) = Trailblazer::Developer.wtf?(Push, [{now: now, data_to_store: trace_data, **options}, {}])
+        _signal, (ctx, _) = Trailblazer::Activity.(Push, {now: now, data_to_store: trace_data, **options})
+        # signal, (ctx, _) = Push.invoke([{now: now, data_to_store: trace_data, **options}, {}])
+
+        session         = ctx[:session]
+        stored_trace_id = ctx[:id]
+        session_updated = ctx[:session_updated]
+
+        return session, stored_trace_id, session_updated
+      end
+    end # Debugger
+  end
+end

data/lib/trailblazer/pro/operation/WTF.rb

@@ -0,0 +1,17 @@
+module Trailblazer
+  module Pro
+    module Operation
+      module WTF
+        # {Operation.WTF?} will always use web tracing and CLI.
+        def WTF?(options)
+          call_with_public_interface(
+            options, 
+            {}, 
+            invoke_class:     Trailblazer::Pro::Trace::Wtf, 
+            present_options: {render_wtf: true}
+          )
+        end
+      end
+    end # Operation
+  end
+end

data/lib/trailblazer/pro/operation/call.rb

@@ -0,0 +1,24 @@
+module Trailblazer
+  module Pro
+    module Operation
+      # @private This is experimental.
+      module Call
+        # This is the monkey-patch for {Operation.call}.
+        # Here we decide whether to use tracing, and what to render,
+        # or if we should bypass tracing.
+        def call_with_public_interface(options, flow_options, **circuit_options)
+          trace_strategy, present_options_merge = Pro::Session.trace_guards.(self, options)
+
+          if trace_strategy
+            # trace_strategy.invoke(activity, [ctx, {}], present_options: present_options_merge)
+
+              # local invoke_class is overridden by circuit_options
+            super(options, flow_options, invoke_class: trace_strategy, **circuit_options, present_options: present_options_merge)
+          else
+            super
+          end
+        end
+      end
+    end # Operation
+  end
+end

data/lib/trailblazer/pro/session.rb

@@ -0,0 +1,82 @@
+module Trailblazer
+  module Pro
+    # DISCUSS: do we want {id_token} here explicitely?
+    # Data structure to hold all data values necessary to keep an authenticated
+    # session with Firebase.
+    class Session < Struct.new(:expires_at, :jwt_token_exp, :id_token, :firebase_upload_url, :firestore_fields_template, :firebase_refresh_url, :firebase_signin_url, :refresh_token, :api_key, :trailblazer_pro_host, keyword_init: true)
+      singleton_class.attr_accessor :wtf_present_options
+      singleton_class.attr_accessor :session
+      singleton_class.attr_accessor :trace_guards
+
+      self.trace_guards = Trailblazer::Pro::Trace::Decision.new([]) # here we say "don't trace anything!"
+      # .trace_guards = Pro::Trace::Decision.new([->(*) { [Trace::Wtf, {}] }]) # always use Pro web/CLI tracing per default.
+
+      class Uninitialized < Struct.new(:api_key, :trailblazer_pro_host, keyword_init: true)
+      end
+
+      def self.serialize(session)
+        attributes = session.to_h
+        attributes = attributes.slice(*(attributes.keys - [:expires_at]))
+
+        JSON.dump(attributes)
+      end
+
+      def self.deserialize(json)
+        data = JSON.parse(json)
+
+        options = data.key?("jwt_token_exp") ? {expires_at: Trace.parse_exp(data["jwt_token_exp"])} : {}
+
+        data
+          .merge(options) # TODO: use representer
+          .collect { |k, v| [k.to_sym, v] }
+          .to_h
+      end
+    end
+
+    # TODO:
+    #   pass session, e.g. from RAils/tmp
+    def self.initialize!(api_key:, id_token: nil, render_wtf: true, **options)
+      Session.wtf_present_options = {
+        render_method:  Trailblazer::Pro::Debugger,
+        render_wtf:     render_wtf,
+        # api_key:        api_key,
+        # **options
+      }
+
+      if id_token
+        Session.session = Trailblazer::Pro::Session.new(api_key: api_key, id_token: id_token, **options)
+      else
+        Session.session = Trailblazer::Pro::Session::Uninitialized.new(api_key: api_key, **options)
+      end
+    end
+
+    def self.trace_operations!(operation_hash)
+      Trailblazer::Pro::Session.trace_guards = DSL.trace_operations(operation_hash)
+    end
+
+    module DSL
+      module_function
+
+      def trace_operations(operation_hash)
+        decisions =
+          if operation_hash == :all
+            Trailblazer::Operation.extend(Trailblazer::Pro::Operation::Call)
+
+            raise "implement me"
+          elsif operation_hash.is_a?(Hash)
+            operation_hash.collect do |operation, strategy| # DISCUSS: this can be easily made faster for runtime.
+              operation.extend(Trailblazer::Pro::Operation::Call) # only extend selected OPs.
+
+              strategy = Trailblazer::Pro::Trace::Wtf if strategy === true # defaulting.
+
+              ->(activity, *) { activity == operation ? [strategy, {}] : false }
+            end
+          else
+            []
+          end
+
+        Trace::Decision.new(decisions)
+      end
+    end
+  end
+end

data/lib/trailblazer/pro/trace/decision.rb

@@ -0,0 +1,15 @@
+module Trailblazer::Pro
+  module Trace
+    # Used in Activity.call monkey-patch.
+    class Decision < Struct.new(:guards)
+      def call(activity, ctx) # DISCUSS: signature not stable, yet.
+        guards.each do |guard|
+          result = guard.(activity, ctx) and return result # DISCUSS: {ctx.to_hash}?
+        end
+
+        false
+      end
+    end
+  end
+end
+

data/lib/trailblazer/pro/trace/refresh.rb

@@ -0,0 +1,33 @@
+module Trailblazer::Pro
+  module Trace
+    class Refresh < Trailblazer::Activity::Railway
+      step :refresh_id_token
+      step Trace.method(:parse_response)
+      step :extract_id_token
+      step :extract_refresh_token
+      step Trace.method(:parse_jwt_token)
+      step Trace.method(:parse_expires_at)
+
+      def refresh_id_token(ctx, http: Faraday, refresh_token:, firebase_refresh_url:, **)
+        ctx[:response] = http.post(
+          firebase_refresh_url,
+          {
+            refresh_token:  refresh_token,
+            grant_type:     "refresh_token"
+          }.to_json,
+          {'Content-Type'=>'application/json', "Accept": "application/json"}
+        )
+
+        ctx[:response].status == 200
+      end
+
+      def extract_id_token(ctx, parsed_response:, **)
+        ctx[:id_token] = parsed_response["id_token"]
+      end
+
+      def extract_refresh_token(ctx, parsed_response:, **)
+        ctx[:refresh_token] = parsed_response["refresh_token"]
+      end
+    end
+  end
+end

data/lib/trailblazer/pro/trace/signin.rb

@@ -0,0 +1,97 @@
+module Trailblazer::Pro
+  module Trace
+    def self.parse_response(ctx, response:, **)
+      ctx[:parsed_response] = JSON.parse(response.body)
+    end
+
+    require "jwt"
+    require "date"
+    def self.parse_jwt_token(ctx, id_token:, **)
+      token, _ = JWT.decode(id_token, nil, false, algorithm: "RS256")
+
+      ctx[:jwt_token_exp] = token["exp"]
+      # ctx[:jwt_token] = token
+    end
+
+    def self.parse_expires_at(ctx, jwt_token_exp:, **)
+      ctx[:expires_at] = parse_exp(jwt_token_exp)
+    end
+
+    def self.parse_exp(exp)
+      DateTime.strptime(exp.to_s, "%s")
+    end
+
+    def self.valid?(ctx, now:, expires_at:, **)
+# FIXME
+      puts "id_token expires at #{expires_at}, that is in #{((expires_at - now) * 24 * 60 * 60).to_i} seconds"
+
+      now < expires_at
+    end
+
+    class Signin < Trailblazer::Activity::Railway
+      step :request_custom_token
+      step Trace.method(:parse_response)
+      step :extract_custom_token
+      step :extract_data_for_firebase
+      step :request_id_token
+      step Trace.method(:parse_response), id: :parse_firebase_response
+      step :extract_id_token
+      step :extract_refresh_token
+      step Trace.method(:parse_jwt_token)
+      step Trace.method(:parse_expires_at)
+      # left ->(ctx, response:, **) { puts response.status } #  FIXME: better error handling!
+
+      PRO_SIGNIN_PATH = "/api/v1/signin_with_api_key"
+
+      # DISCUSS: this is the "outgoing" contract, the variables we should store in {session_params}.
+      SESSION_VARIABLE_NAMES = [
+        #:custom_token,
+        :id_token, :refresh_token, :expires_at, :jwt_token_exp, :firebase_signin_url, :firebase_refresh_url, :firebase_upload_url, :firestore_fields_template
+      ]
+
+      def request_custom_token(ctx, http: Faraday, api_key:, trailblazer_pro_host: "https://pro.trailblazer.to", **) # DISCUSS: do we like the defaulting?
+        ctx[:response] = http.post(
+          "#{trailblazer_pro_host}#{PRO_SIGNIN_PATH}",
+          {
+            api_key: api_key,
+          }.to_json,
+          {'Content-Type'=>'application/json', "Accept": "application/json"}
+        )
+
+        ctx[:response].status == 200
+      end
+
+      def extract_custom_token(ctx, parsed_response:, **)
+        ctx[:custom_token] = parsed_response["custom_token"]
+      end
+
+      def extract_data_for_firebase(ctx, parsed_response:, **)
+        ctx[:firebase_signin_url]   = parsed_response["firebase_signin_url"] or return
+        ctx[:firebase_refresh_url]  = parsed_response["firebase_refresh_url"] or return
+        ctx[:firebase_upload_url]   = parsed_response["firebase_upload_url"] or return # needed in {Trace::Store}.
+        ctx[:firestore_fields_template]  = parsed_response["firebase_upload_data"] or return
+      end
+
+      def request_id_token(ctx, http: Faraday, firebase_signin_url:, custom_token:, **)
+        ctx[:response] = http.post(
+          firebase_signin_url,
+          {
+            token:              custom_token,
+            returnSecureToken:  true
+          }.to_json,
+          {'Content-Type'=>'application/json', "Accept": "application/json"}
+        )
+
+        ctx[:response].status == 200
+      end
+
+      def extract_id_token(ctx, parsed_response:, **)
+        ctx[:id_token] = parsed_response["idToken"]
+      end
+
+      def extract_refresh_token(ctx, parsed_response:, **)
+        ctx[:refresh_token] = parsed_response["refreshToken"]
+      end
+    end # Signin
+  end
+end

data/lib/trailblazer/pro/trace/store.rb

@@ -0,0 +1,38 @@
+module Trailblazer::Pro
+  module Trace
+    class Store < Trailblazer::Activity::Railway
+      step :upload
+      step :extract_id
+      fail :error
+
+      def upload(ctx, firebase_upload_url:, data_to_store:, id_token:, firestore_fields_template:, **)
+        fields = data_to_store[:fields].merge(firestore_fields_template)
+
+        json_to_store = JSON.dump(data_to_store.merge(fields: fields))#.to_json
+
+        # puts "@@@@@ DATA SIZE: #{json_to_store.size / 1024} kb"
+
+        ctx[:response] = Faraday.post(
+          firebase_upload_url,
+          json_to_store,
+          {'Content-Type'=>'application/json', "Accept": "application/json",
+            "Authorization": "Bearer #{id_token}"
+          }
+        )
+
+        ctx[:response].status == 200
+      end
+
+      def extract_id(ctx, response:, **)
+        parsed_response = JSON.parse(response.body)
+
+        ctx[:firestore_name]  = parsed_response["name"]
+        ctx[:id]              = ctx[:firestore_name].split("/").last
+      end
+
+      def error(ctx, response:, **)
+        puts response.inspect
+      end
+    end
+  end
+end

data/lib/trailblazer/pro/trace/wtf.rb

@@ -0,0 +1,38 @@
+module Trailblazer::Pro
+  module Trace
+    module Wtf
+      module_function
+      # DISCUSS: this is called inside the monkey-patch for Activity/Operation.()
+      # in {Pro::Call.call}.
+      def call(*args, present_options: {}, **options)
+        global_present_options =  Session.wtf_present_options
+        raise "[Trailblazer] Please configure your PRO API key." if global_present_options.nil?
+
+        present_options =
+          global_present_options
+            .merge(present_options)
+            .merge(session: Session.session)
+
+        returned = Trailblazer::Developer::Wtf.invoke( # identical to {Developer.wtf?}.
+          *args,
+          present_options: present_options,
+          **options
+        )
+
+        (session, _trace_id, _debugger_url, _trace_envelope, session_updated) = returned[-1]
+
+        update_session!(session) if session_updated # DISCUSS: this is a hook for pro-rails, not a massive fan.
+
+        returned
+      end
+
+      class << self
+        alias invoke call
+      end
+
+      def update_session!(session)
+        Session.session = session
+      end
+    end
+  end
+end

data/lib/trailblazer/pro/version.rb

@@ -1,5 +1,5 @@
 module Trailblazer
   module Pro
-    VERSION = "0.0.1"
+    VERSION = "0.0.2"
   end
 end

data/lib/trailblazer/pro.rb

@@ -1,10 +1,20 @@
-# frozen_string_literal: true
-
 require_relative "pro/version"
+require "trailblazer/activity/dsl/linear"
+require "faraday"
 
 module Trailblazer
   module Pro
-    class Error < StandardError; end
     # Your code goes here...
   end
 end
+
+require_relative "pro/trace/decision"
+require_relative "pro/session"
+require_relative "pro/trace/signin"
+require_relative "pro/trace/refresh"
+require_relative "pro/trace/store"
+require_relative "pro/trace/wtf"
+require_relative "pro/debugger"
+require_relative "pro/call/activity"
+require_relative "pro/operation/call"
+require_relative "pro/operation/WTF"

data/lib/trailblazer-pro.rb

@@ -0,0 +1 @@
+require "trailblazer/pro"

data/trailblazer-pro.gemspec

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require_relative "lib/trailblazer/pro/version"
 
 Gem::Specification.new do |spec|
@@ -8,8 +6,7 @@ Gem::Specification.new do |spec|
   spec.authors       = ["Nick Sutterer"]
   spec.email         = ["apotonick@gmail.com"]
 
-  spec.summary       = "Integrations for our BPMN editor."
-  # spec.description   = "TODO: Write a longer description or delete this line."
+  spec.summary       = "Integration code for TRB PRO."
   spec.homepage      = "https://trailblazer.to/2.1/docs/pro.html"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.4.0")
 
@@ -27,8 +24,13 @@ Gem::Specification.new do |spec|
   spec.require_paths = ["lib"]
 
   # Uncomment to register a new dependency of your gem
-  # spec.add_dependency "example-gem", "~> 1.0"
+  spec.add_dependency "trailblazer-activity", ">= 0.16.1", "< 0.17.0"
+  # spec.add_dependency "trailblazer-activity-dsl-linear", "~> 1.2"
+  spec.add_dependency "trailblazer-developer", ">= 0.1.0", "< 0.2.0"
+  spec.add_dependency "jwt"
+  spec.add_dependency "faraday"
+  spec.add_development_dependency "trailblazer-operation"
 
-  # For more information and examples about making a new gem, checkout our
-  # guide at: https://bundler.io/guides/creating_gem.html
+  spec.add_development_dependency "minitest-line"
+  spec.add_development_dependency "rake"
 end

metadata

@@ -1,15 +1,125 @@
 --- !ruby/object:Gem::Specification
 name: trailblazer-pro
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
 platform: ruby
 authors:
 - Nick Sutterer
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2022-02-17 00:00:00.000000000 Z
-dependencies: []
+date: 2023-08-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: trailblazer-activity
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.16.1
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.17.0
+- !ruby/object:Gem::Dependency
+  name: trailblazer-developer
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.1.0
+    - - "<"
+      - !ruby/object:Gem::Version
+        version: 0.2.0
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: faraday
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: trailblazer-operation
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest-line
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
 description: 
 email:
 - apotonick@gmail.com
@@ -25,9 +135,18 @@ files:
 - Rakefile
 - bin/console
 - bin/setup
+- lib/trailblazer-pro.rb
 - lib/trailblazer/pro.rb
-- lib/trailblazer/pro/client.rb
-- lib/trailblazer/pro/generate.rb
+- lib/trailblazer/pro/call/activity.rb
+- lib/trailblazer/pro/debugger.rb
+- lib/trailblazer/pro/operation/WTF.rb
+- lib/trailblazer/pro/operation/call.rb
+- lib/trailblazer/pro/session.rb
+- lib/trailblazer/pro/trace/decision.rb
+- lib/trailblazer/pro/trace/refresh.rb
+- lib/trailblazer/pro/trace/signin.rb
+- lib/trailblazer/pro/trace/store.rb
+- lib/trailblazer/pro/trace/wtf.rb
 - lib/trailblazer/pro/version.rb
 - trailblazer-pro.gemspec
 homepage: https://trailblazer.to/2.1/docs/pro.html
@@ -54,5 +173,5 @@ requirements: []
 rubygems_version: 3.2.3
 signing_key: 
 specification_version: 4
-summary: Integrations for our BPMN editor.
+summary: Integration code for TRB PRO.
 test_files: []

data/lib/trailblazer/pro/client.rb

@@ -1,95 +0,0 @@
-require "faraday"
-require "base64"
-require "json"
-require "representable/json"
-
-module Trailblazer::Developer
-  module Client
-    Diagram = Struct.new(:id, :body)
-
-    class Diagram::Representer < Representable::Decorator
-      include Representable::JSON
-      property :id
-      property :body, as: :diagram
-    end
-
-    module_function
-
-    def Diagram(id, body)
-      Diagram.new(id, body).freeze
-    end
-
-    def import(id:, query:"", **options)
-      token = retrieve_token(**options)
-      export_diagram(id: id, token: token, query: query, **options)
-    end
-
-    def retrieve_token(email:, api_key:, url: "/signin", **options)
-      body = JSON.generate({email: email, api_key: api_key})
-
-      response = request(token: nil, method: :get, url: url, body: body, **options)
-      return false unless response.status == 200
-
-      # token = CGI::Cookie.parse(response.headers["set-cookie"])["token"][0]
-      JSON.parse(response.body)["token"]
-    end
-
-    def export_diagram(id:, query:, **options)
-      response = request(body: nil, url: "/api/v1/diagrams/#{id}/export#{query}", method: :get, **options)
-
-#      parse_response(response)
-      response.body
-    end
-
-    def duplicate(id:, **options)
-      token = retrieve_token(**options)
-
-      response = request(body: nil, token: token, url: "/api/v1/diagrams/#{id}/duplicate", method: :get, **options)
-      parse_response(response)
-    end
-
-    # DISCUSS: do we need that?
-    def new_diagram(token:, **options)
-      response = request(body: nil, url: "/api/v1/diagrams/new", method: :get, token: token, **options)
-
-      # TODO: use Dry::Struct
-      # TODO: handle unauthorized/errors
-      parse_response(response)
-    end
-
-    def request(host:, url:, method:, token:, body:, **)
-      conn = Faraday.new(url: host)
-
-      conn.send(method) do |req|
-        req.url url
-        req.headers["Content-Type"] = "application/json"
-        req.body = body
-        req.headers["Authorization"] = token
-      end
-    end
-
-    def parse_response(response)
-      diagram = Diagram.new
-      Diagram::Representer.new(diagram).from_json(response.body) # a parsed hash would be cooler?
-
-      diagram
-    end
-
-    # TODO: remove me!
-    def self.push(operation:, name:)
-      xml = Trailblazer::Diagram::BPMN.to_xml(operation["__activity__"], operation["__sequence__"].map(&:id))
-      token = "Bearer eyJ0eXAiOiJKV1QiLCJhbGciOiJub25lIn0.eyJpZCI6MywidXNlcm5hbWUiOiJhcG90b25pY2siLCJlbWFpbCI6Im5pY2tAdHJhaWxibGF6ZXIudG8ifQ." # rubocop:disable Metrics/LineLength
-      conn = Faraday.new(url: "https://api.trb.to")
-      response = conn.post do |req|
-        req.url "/dev/v1/import"
-        req.headers["Content-Type"] = "application/json"
-        req.headers["Authorization"] = token
-        require "base64"
-
-        req.body = %({ "name": "#{name}", "xml":"#{Base64.strict_encode64(xml)}" })
-      end
-
-      puts response.status.inspect
-    end
-  end
-end

data/lib/trailblazer/pro/generate.rb

@@ -1,99 +0,0 @@
-gem "representable"
-require "representable/hash"
-require "trailblazer/activity/dsl/linear" # Railway.
-
-module Trailblazer
-  module Developer
-    # Computes an {Intermediate} data structure from a TRB-editor.js file.
-    module Generate
-      module_function
-
-      Element = Struct.new(:id, :type, :linksTo, :data, :label, :parent)
-      Arrow   = Struct.new(:target, :label, :message, :target_lane)
-
-      module Representer
-        class Activity < Representable::Decorator
-          include Representable::Hash
-
-          collection :elements, class: Element do
-            property :id
-            property :type
-            collection :linksTo, class: Arrow, default: ::Declarative::Variables::Append([]) do
-              property :target
-              property :label
-              property :message
-              property :target_lane
-            end
-            property :data, default: {}
-
-            property :label
-            property :parent # TODO: remove?
-          end
-        end
-      end
-
-      def call(hash)
-        _, (ctx, _) = Activity::TaskWrap.invoke(Pipeline, [{hash: hash}, {}])
-        ctx[:intermediate]
-      end
-
-      def transform_from_hash(ctx, hash:, parser: Representer::Activity, **)
-        ctx[:elements] = parser.new(OpenStruct.new).from_hash(hash).elements
-      end
-
-      def find_start_events(ctx, elements:, **)
-        ctx[:start_events] = elements.find_all { |el| el.type == "Event" }
-      end
-
-      def compute_intermediate(ctx, elements:, start_events:, **)
-        end_events   = elements.find_all { |el| el.type == "EndEventTerminate" } # DISCUSS: is it really called TERMINATE?
-
-        inter = Activity::Schema::Intermediate
-
-        wiring = elements.collect { |el|
-          data = data_for(el)
-
-          [inter.TaskRef(el.id, data), el.linksTo.collect { |arrow| inter.Out(semantic_for(**arrow.to_h), arrow.target) } ] }
-        wiring = Hash[wiring]
-
-        # end events need this stupid special handling
-        # DISCUSS: currently, the END-SEMANTIC is read from the event's label.
-        wiring = wiring.merge(Hash[
-          end_events.collect do |_end|
-            ref, = wiring.find { |ref, _| ref.id == _end.id }
-
-            [ref, [inter.Out(semantic_for(**_end.to_h)|| raise, nil)]] # TODO: test the raise, happens when the semantic of an End can't be distinguished. # TODO: don't extract semantic from :label but from :data.
-          end
-        ])
-        # pp wiring
-
-        ctx[:intermediate] = inter.new(wiring, end_events.collect(&:id), start_events.collect(&:id))
-      end
-
-      # private
-
-      def data_for(element)
-        {type: element.type}.merge(element.data)
-      end
-
-      # We currently use the {:label} field of an arrow to encode an output semantic.
-      # The {:symbol_style} part will be filtered out as semantic. Defaults to {:success}.
-      def semantic_for(label:nil, **)
-        return :success unless label
-
-        extract_semantic(label)
-      end
-
-      def extract_semantic(label)
-        label.to_sym
-      end
-
-      class Pipeline < Trailblazer::Activity::Railway
-        step Generate.method(:transform_from_hash),   id: :transform_from_hash
-        step Generate.method(:find_start_events),     id: :find_start_events
-        step Generate.method(:compute_intermediate),  id: :compute_intermediate
-      end
-    end
-  end
-end
-# [Inter::Out(:success, nil)]