workato-connector-sdk 0.1.0

data/exe/workato

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'workato/cli/main'
+Workato::CLI::Main.start

data/lib/workato/cli/edit_command.rb

@@ -0,0 +1,71 @@
+# frozen_string_literal: true
+
+require 'active_support/encrypted_configuration'
+
+module Workato
+  module CLI
+    class EditCommand
+      def initialize(path:, options:)
+        @encrypted_file_path = path
+        @key_path = options[:key] || Workato::Connector::Sdk::DEFAULT_MASTER_KEY_PATH
+        @encrypted_config ||= ActiveSupport::EncryptedConfiguration.new(
+          config_path: encrypted_file_path,
+          key_path: @key_path,
+          env_key: Workato::Connector::Sdk::DEFAULT_MASTER_KEY_ENV,
+          raise_if_missing_key: false
+        )
+      end
+
+      def call
+        ensure_editor_available || return
+        ensure_encryption_key_present
+
+        catch_editing_exceptions do
+          encrypted_config.change do |tmp_path|
+            system("#{ENV['EDITOR']} #{tmp_path}")
+          end
+        end
+
+        puts 'File encrypted and saved.'
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        puts "Couldn't decrypt #{encrypted_file_path}. Perhaps you passed the wrong key?"
+      end
+
+      private
+
+      attr_reader :key_path,
+                  :encrypted_file_path,
+                  :encrypted_config
+
+      def ensure_encryption_key_present
+        return if encrypted_config.key.present?
+
+        Generators::MasterKeyGenerator.new.call(@key_path)
+      end
+
+      def ensure_editor_available
+        return true if ENV['EDITOR'].to_s.present?
+
+        puts <<~HELP
+          No $EDITOR to open file in. Assign one like this:
+
+          EDITOR="mate --wait" workato edit #{encrypted_file_path}
+
+          For editors that fork and exit immediately, it's important to pass a wait flag,
+          otherwise the credentials will be saved immediately with no chance to edit.
+
+        HELP
+
+        false
+      end
+
+      def catch_editing_exceptions
+        yield
+      rescue Interrupt
+        puts 'Aborted changing file: nothing saved.'
+      rescue ActiveSupport::EncryptedFile::MissingKeyError => e
+        puts e.message
+      end
+    end
+  end
+end

data/lib/workato/cli/exec_command.rb

@@ -0,0 +1,191 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'ruby-progressbar'
+
+module Workato
+  module CLI
+    class ExecCommand
+      include Thor::Shell
+
+      def initialize(path:, options:)
+        @path = path
+        @options = options
+      end
+
+      def call
+        load_from_default_files
+        inspect_params(params)
+        output = with_progress { execute_path }
+        show_output(output)
+        output
+      end
+
+      private
+
+      attr_reader :path,
+                  :options
+
+      # rubocop:disable Style/GuardClause
+      def load_from_default_files
+        if File.exist?(Workato::Connector::Sdk::DEFAULT_SCHEMAS_PATH)
+          Workato::Connector::Sdk::WorkatoSchemas.from_json
+        end
+        if File.exist?(Workato::Connector::Sdk::DEFAULT_LOOKUP_TABLES_PATH)
+          Workato::Connector::Sdk::LookupTables.from_yaml
+        end
+        if File.exist?(Workato::Connector::Sdk::DEFAULT_ACCOUNT_PROPERTIES_PATH)
+          Workato::Connector::Sdk::AccountProperties.from_yaml
+        end
+        if File.exist?(Workato::Connector::Sdk::DEFAULT_ENCRYPTED_ACCOUNT_PROPERTIES_PATH)
+          Workato::Connector::Sdk::AccountProperties.from_encrypted_yaml
+        end
+      end
+      # rubocop:enable Style/GuardClause
+
+      def params
+        @params ||= {
+          connector: connector,
+          settings: settings,
+          input: from_json(options[:input]),
+          output: from_json(options[:input]),
+          webhook_subscribe_output: from_json(options[:input]),
+          args: from_json(options[:args]).presence || [],
+          extended_input_schema: from_json(options[:extended_input_schema]).presence || [],
+          extended_output_schema: from_json(options[:extended_output_schema]).presence || [],
+          config_fields: from_json(options[:config_fields]),
+          closure: from_json(options[:closure], parse_json_times: true).presence,
+          payload: from_json(options[:webhook_payload]),
+          params: from_json(options[:webhook_params]),
+          headers: from_json(options[:webhook_headers]),
+          webhook_url: options[:webhook_url],
+          recipe_id: SecureRandom.uuid
+        }
+      end
+
+      def connector
+        Workato::Connector::Sdk::Connector.from_file(
+          options[:connector] || Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH,
+          settings
+        )
+      end
+
+      def settings
+        return @settings if defined?(@settings)
+
+        settings_store = Workato::Connector::Sdk::Settings.new(
+          path: options[:settings],
+          name: options[:connection],
+          key_path: options[:key]
+        )
+        @settings = settings_store.read
+
+        Workato::Connector::Sdk::Operation.on_settings_updated = lambda do |_, _, exception, new_settings|
+          $stdout.pause if verbose?
+          say('')
+          say("Refresh token triggered on response \"#{exception}\"")
+          loop do
+            answer = ask('Updated settings file with new connection attributes? (Yes or No)').to_s.downcase
+            break if %w[n no].include?(answer)
+            break settings_store.update(new_settings) if %w[y yes].include?(answer)
+          end
+          $stdout.resume if verbose?
+        end
+
+        @settings
+      end
+
+      def from_json(path, parse_json_times: false)
+        old_parse_json_times = ActiveSupport.parse_json_times
+        ::ActiveSupport.parse_json_times = parse_json_times
+        result = path ? ::ActiveSupport::JSON.decode(File.read(path)) : {}
+        ::ActiveSupport.parse_json_times = old_parse_json_times
+        result
+      end
+
+      def inspect_params(params)
+        return unless verbose?
+
+        if params[:settings].present?
+          say('SETTINGS')
+          jj params[:settings]
+        end
+
+        say('INPUT')
+        jj params[:input]
+      end
+
+      def execute_path
+        methods = path.split('.')
+        method = methods.pop
+        object = methods.inject(params[:connector]) { |obj, m| obj.public_send(m) }
+        parameters = object.method(method).parameters.reject { |p| p[0] == :block }.map(&:second)
+        args = params.values_at(*parameters)
+        if parameters.last == :args
+          args = args.take(args.length - 1) + Array.wrap(args.last).flatten(1)
+        end
+        object.public_send(method, *args)
+      rescue Exception => e # rubocop:disable Lint/RescueException
+        raise e if options[:debug]
+
+        e.message
+      end
+
+      def show_output(output)
+        if options[:output].present?
+          File.open(options[:output], 'w') do |f|
+            f.write(JSON.dump(output))
+          end
+        elsif options[:output].nil?
+          say('OUTPUT') if verbose?
+          jj output
+        end
+      end
+
+      def verbose?
+        !!options[:verbose]
+      end
+
+      def with_progress
+        return yield unless verbose?
+
+        say('')
+
+        old_stdout = $stdout
+        progress_bar = ProgressBar.create(total: nil, output: old_stdout)
+        $stdout = ProgressLogger.new(progress_bar)
+        RestClient.log = $stdout
+
+        dots = Thread.start do
+          loop do
+            progress_bar.increment unless progress_bar.paused?
+            sleep(0.2)
+          end
+        end
+        output = yield
+        dots.kill
+        progress_bar.finish
+
+        $stdout = old_stdout
+
+        say('')
+
+        output
+      end
+
+      class ProgressLogger < SimpleDelegator
+        def initialize(progress)
+          super($stdout)
+          @progress = progress
+        end
+
+        delegate :log, :pause, :resume, to: :@progress
+
+        alias << log
+        alias write log
+        alias puts log
+        alias print log
+      end
+    end
+  end
+end

data/lib/workato/cli/generate_command.rb

@@ -0,0 +1,105 @@
+# frozen_string_literal: true
+
+module Workato
+  module CLI
+    class GenerateCommand < Thor
+      include Thor::Actions
+
+      TEST_TYPES = %w[trigger action pick_list object_definition method].freeze
+
+      def self.source_root
+        File.expand_path('../../../templates', __dir__)
+      end
+
+      desc 'test', 'Generate empty test for connector'
+
+      method_option :connector, type: :string, aliases: '-c', desc: 'Path to connector source code',
+                                lazy_default: Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH
+      method_option :action, type: :string, aliases: '-a', desc: 'Create test for Action with name'
+      method_option :trigger, type: :string, aliases: '-t', desc: 'Create test for Trigger with name'
+      method_option :pick_list, type: :string, aliases: '-p', desc: 'Create test for Pick List with name'
+      method_option :object_definition, type: :string, aliases: '-o',
+                                        desc: 'Create test for Object Definition with name'
+      method_option :method, type: :string, aliases: '-m', desc: 'Create test for Method with name'
+
+      long_desc <<~HELP
+        The 'workato generate test' command analyzes existing connector source and creates an empty test for
+        all connector's definitions.
+
+        Example:
+
+          workato generate test # This generates a skeletal tests for all connector's definitions.
+
+          workato generate test --action=test_action # This generates an empty test for `test_action` only.
+
+          workato generate test --method=some_method
+      HELP
+
+      def test
+        create_spec_files
+      end
+
+      desc 'schema', 'Generate schema by JSON example'
+      def schema
+        say <<~HELP
+          Generate schema is not implemented yet.
+          Use Workato UI "JSON to Schema" converter for now.
+        HELP
+      end
+
+      private
+
+      def create_spec_files
+        definitions = options.slice(*TEST_TYPES)
+        if definitions.any?
+          definitions.each do |type, name|
+            create_spec_file(type, name)
+          end
+        else
+          ensure_connector_source
+
+          template('spec/connector_spec.rb.erb', 'spec/connector_spec.rb', skip: true)
+          TEST_TYPES.each do |type|
+            (connector.source[type.pluralize] || {}).each do |(name, _definition)|
+              create_spec_file(type, name)
+            end
+          end
+        end
+      end
+
+      def ensure_connector_source
+        return if connector
+
+        error "Can't find connector source code"
+        exit
+      end
+
+      def create_spec_file(type, name)
+        template(
+          partial(type),
+          "spec/#{type}s/#{sanitized_filename(name)}_spec.rb",
+          context: binding,
+          skip: true
+        )
+      end
+
+      def connector
+        return @connector if @connector
+
+        @connector = Workato::Connector::Sdk::Connector.from_file(
+          options[:connector] || Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH
+        )
+      rescue StandardError
+        nil
+      end
+
+      def partial(type)
+        "spec/#{type.downcase}_spec.rb.erb"
+      end
+
+      def sanitized_filename(name)
+        name.downcase.gsub(/[^0-9A-z.\-]/, '_')
+      end
+    end
+  end
+end

data/lib/workato/cli/generators/connector_generator.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Workato
+  module CLI
+    module Generators
+      class ConnectorGenerator < Thor::Group
+        include Thor::Actions
+
+        argument :path, type: :string
+
+        def self.source_root
+          File.expand_path('../../../../templates', __dir__)
+        end
+
+        def create_root
+          self.destination_root = path
+
+          empty_directory '.'
+          FileUtils.cd(path)
+        end
+
+        def create_gemfile
+          template('Gemfile.erb', 'Gemfile')
+        end
+
+        def create_connector_file
+          template('connector.rb.erb', 'connector.rb')
+        end
+
+        def create_spec_files
+          template('.rspec.erb', '.rspec')
+
+          @vcr_record_mode = ask(<<~HELP)
+            Please select default HTTP mocking behavior suitable for your project?
+
+            1 - secure. Cause an error to be raised for any unknown requests, all request recordings are encrypted.
+                        To record a new cassette you need set VCR_RECORD_MODE environment variable
+
+                        Example: VCR_RECORD_MODE=once bundle exec rspec spec/actions/test_action_spec.rb
+
+            2 - simple. Record new interaction if it is a new request, requests are stored as plain text and expose secret tokens.
+          HELP
+
+          MasterKeyGenerator.new.call if @vcr_record_mode == '1'
+
+          template('spec/spec_helper.rb.erb', 'spec/spec_helper.rb')
+          template('spec/connector_spec.rb.erb', 'spec/connector_spec.rb')
+        end
+
+        def bundle_install
+          bundle_command('install')
+        end
+
+        def show_next_steps
+          say <<~HELP
+            The new Workato Custom Connector project created at #{path}.
+
+            Now, edit the created file. Add actions, triggers or methods and generate tests for them
+
+            cd #{path} && workato generate test
+          HELP
+        end
+
+        private
+
+        attr_reader :vcr_record_mode
+
+        def name
+          File.basename(path)
+        end
+
+        def bundle_command(command)
+          say_status :run, "bundle #{command}"
+
+          bundle_command = Gem.bin_path('bundler', 'bundle')
+
+          require 'bundler'
+          Bundler.with_original_env do
+            exec_bundle_command(bundle_command, command)
+          end
+        end
+
+        def exec_bundle_command(bundle_command, command)
+          full_command = %("#{Gem.ruby}" "#{bundle_command}" #{command})
+          if options[:quiet]
+            system(full_command, out: File::NULL)
+          else
+            system(full_command)
+          end
+        end
+      end
+    end
+  end
+end