workato-connector-sdk 0.1.0

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

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+module Workato
+  module CLI
+    module Generators
+      class MasterKeyGenerator < Thor::Group
+        include Thor::Actions
+
+        no_commands do
+          def call(key_path = Workato::Connector::Sdk::DEFAULT_MASTER_KEY_PATH)
+            create_key_file(key_path)
+            ignore_key_file(key_path)
+          end
+        end
+
+        def create_key_file(key_path = Workato::Connector::Sdk::DEFAULT_MASTER_KEY_PATH)
+          raise "#{key_path} already exists" if File.exist?(key_path)
+
+          key = ActiveSupport::EncryptedFile.generate_key
+
+          say "Adding #{key_path} to store the encryption key: #{key}"
+          say ''
+          say 'Save this in a password manager your team can access.'
+          say "Don't store the file in a public place, make sure you're sharing it privately."
+          say ''
+          say 'If you lose the key, no one, including you, can access anything encrypted with it.'
+
+          say ''
+
+          File.open(key_path, 'w') do |f|
+            f.write(key)
+            f.chmod 0o600
+          end
+
+          say ''
+        end
+
+        def ignore_key_file(key_path = Workato::Connector::Sdk::DEFAULT_MASTER_KEY_PATH)
+          ignore = [' ', "/#{key_path}", ' '].join("\n")
+          if File.exist?('.gitignore')
+            unless File.read('.gitignore').include?(ignore)
+              say "Ignoring #{key_path} so it won't end up in Git history:"
+              say ''
+              append_to_file '.gitignore', ignore
+              say ''
+            end
+          else
+            say "IMPORTANT: Don't commit #{key_path}. Add this to your ignore file:"
+            say ignore, :on_green
+            say ''
+          end
+        end
+      end
+    end
+  end
+end

data/lib/workato/cli/main.rb

@@ -0,0 +1,142 @@
+# frozen_string_literal: true
+
+require 'thor'
+require 'workato/connector/sdk'
+require_relative './exec_command'
+require_relative './edit_command'
+require_relative './generate_command'
+require_relative './push_command'
+require_relative './generators/connector_generator'
+require_relative './generators/master_key_generator'
+
+module Workato
+  module CLI
+    class Main < Thor
+      class_option :verbose, type: :boolean
+
+      desc 'exec <PATH>', 'Execute connector defined block'
+      long_desc <<~HELP
+        The 'workato exec' executes connector's lambda block at <PATH>.
+        Lambda's parameters can be provided if needed, see options part.
+
+        Example:
+
+          workato exec actions.foo.execute # This executes execute block of foo action
+
+          workato exec triggers.bar.poll # This executes poll block of bar action
+
+          workato exec methods.bazz --args=input.json # This executes methods with params from input.json
+      HELP
+
+      method_option :connector, type: :string, aliases: '-c', desc: 'Path to connector source code',
+                                lazy_default: Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH
+      method_option :settings, type: :string, aliases: '-s',
+                               desc: 'Path to plain or encrypted file with connection configs, '\
+                                     'passwords, tokens, secrets etc',
+                               lazy_default: Workato::Connector::Sdk::DEFAULT_ENCRYPTED_SETTINGS_PATH
+      method_option :connection, type: :string, aliases: '-n',
+                                 desc: 'Connection name if settings file contains multiple settings'
+      method_option :key, type: :string, aliases: '-k',
+                          lazy_default: Workato::Connector::Sdk::DEFAULT_MASTER_KEY_PATH,
+                          desc: 'Path to file with encrypt/decrypt key. '\
+                          "NOTE: key from #{Workato::Connector::Sdk::DEFAULT_MASTER_KEY_ENV} has higher priority"
+      method_option :input, type: :string, aliases: '-i', desc: 'Path to file with input JSON'
+      method_option :closure, type: :string, desc: 'Path to file with next poll closure JSON'
+      method_option :args, type: :string, aliases: '-a', desc: 'Path to file with method arguments JSON'
+      method_option :extended_input_schema, type: :string,
+                                            desc: 'Path to file with extended input schema definition JSON'
+      method_option :extended_output_schema, type: :string,
+                                             desc: 'Path to file with extended output schema definition JSON'
+      method_option :config_fields, type: :string, desc: 'Path to file with config fields JSON'
+      method_option :webhook_payload, type: :string, aliases: '-w', desc: 'Path to file with webhook payload JSON'
+      method_option :webhook_params, type: :string, desc: 'Path to file with webhook params JSON'
+      method_option :webhook_headers, type: :string, desc: 'Path to file with webhook headers JSON'
+      method_option :webhook_url, type: :string, desc: 'Webhook URL for automatic webhook subscription'
+      method_option :output, type: :string, aliases: '-o', desc: 'Write output to JSON file'
+
+      method_option :debug, type: :boolean
+
+      def exec(path)
+        ExecCommand.new(
+          path: path,
+          options: options
+        ).call
+      end
+
+      desc 'edit <PATH>', 'Edit encrypted file, e.g. settings.yaml.enc'
+
+      method_option :key, type: :string, aliases: '-k',
+                          lazy_default: Workato::Connector::Sdk::DEFAULT_MASTER_KEY_PATH,
+                          desc: 'Path to file with encrypt/decrypt key. '\
+                                "NOTE: key from #{Workato::Connector::Sdk::DEFAULT_MASTER_KEY_ENV} has higher priority"
+
+      def edit(path)
+        EditCommand.new(
+          path: path,
+          options: options
+        ).call
+      end
+
+      def self.exit_on_failure?
+        true
+      end
+
+      long_desc <<~HELP
+        The 'workato new' command creates a new Workato connector with a default
+        directory structure and configuration at the path you specify.
+
+        Example:
+          workato new ~/dev/workato/random
+
+          This generates a skeletal custom connector in ~/dev/workato/random.
+      HELP
+      register(Generators::ConnectorGenerator, 'new', 'new <CONNECTOR_PATH>', 'Inits new connector folder')
+
+      desc 'generate <SUBCOMMAND>', 'Generates code from template'
+      subcommand('generate', GenerateCommand)
+
+      desc 'push <FOLDER>', "Upload and release connector's code"
+      method_option :title,
+                    type: :string,
+                    aliases: '-t',
+                    desc: 'Connector title on the Workato Platform'
+      method_option :description,
+                    type: :string,
+                    aliases: '-d',
+                    desc: 'Path to connector description: Markdown or plain text'
+      method_option :logo,
+                    type: :string,
+                    aliases: '-l',
+                    desc: 'Path to connector logo: png or jpeg file'
+      method_option :notes,
+                    type: :string,
+                    aliases: '-n',
+                    desc: 'Release notes'
+      method_option :connector,
+                    type: :string,
+                    aliases: '-c',
+                    desc: 'Path to connector source code',
+                    lazy_default: Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH
+      method_option :api_email,
+                    type: :string,
+                    desc: 'Email for accessing Workato API or '\
+                          "set #{Workato::CLI::PushCommand::WORKATO_API_EMAIL_ENV} env"
+      method_option :api_token,
+                    type: :string,
+                    desc: 'Token for accessing Workato API or ' \
+                          "set #{Workato::CLI::PushCommand::WORKATO_API_TOKEN_ENV} env"
+      method_option :environment,
+                    type: :string,
+                    enum: Workato::CLI::PushCommand::ENVIRONMENTS.keys,
+                    default: 'live',
+                    desc: 'Server to push connector code to'
+
+      def push(folder)
+        PushCommand.new(
+          folder: folder,
+          options: options
+        ).call
+      end
+    end
+  end
+end

data/lib/workato/cli/push_command.rb

@@ -0,0 +1,208 @@
+# frozen_string_literal: true
+
+require 'uri'
+require 'ruby-progressbar'
+require 'zip'
+
+module Workato
+  module CLI
+    class PushCommand
+      include Thor::Shell
+
+      WORKATO_API_TOKEN_ENV = 'WORKATO_API_TOKEN'
+      WORKATO_API_EMAIL_ENV = 'WORKATO_API_EMAIL'
+
+      ENVIRONMENTS = {
+        'preview' => 'https://app.preview.workato.com',
+        'preview-eu' => 'https://app.preview.eu.workato.com',
+        'live' => 'https://app.workato.com',
+        'live-eu' => 'https://app.eu.workato.com'
+      }.freeze
+
+      API_IMPORT_PATH = '/api/packages/import'
+      API_PACKAGE_PATH = '/api/packages'
+      IMPORT_IN_PROGRESS = 'in_progress'
+
+      DEFAULT_LOGO_PATH = 'logo.png'
+      DEFAULT_README_PATH = 'README.md'
+      PACKAGE_ENTRY_NAME = 'connector.custom_adapter'
+
+      AWAIT_IMPORT_SLEEP_INTERVAL = 15 # seconds
+      AWAIT_IMPORT_TIMEOUT_INTERVAL = 120 # seconds
+
+      def initialize(folder:, options:)
+        @folder_id = folder
+        @options = options
+        @api_base_url = ENVIRONMENTS.fetch(options[:environment])
+        @api_email = options[:api_email] || ENV[WORKATO_API_EMAIL_ENV]
+        @api_token = options[:api_token] || ENV[WORKATO_API_TOKEN_ENV]
+      end
+
+      def call
+        zip_file = build_package
+        say_status :success, 'Build package' if verbose?
+
+        import_id = import_package(zip_file)
+        say_status :success, 'Upload package' if verbose?
+        say_status :waiting, 'Process package' if verbose?
+
+        result = await_import(import_id)
+        if result.fetch('status') == 'failed'
+          say result.fetch('error').gsub("#{PACKAGE_ENTRY_NAME}.json: ", '')
+        else
+          say "Connector was successfully uploaded to #{api_base_url}"
+        end
+      rescue StandardError => e
+        say e.message
+      ensure
+        zip_file&.close(true)
+      end
+
+      private
+
+      attr_reader :options,
+                  :folder_id,
+                  :api_token,
+                  :api_email,
+                  :api_base_url
+
+      def verbose?
+        @options[:verbose]
+      end
+
+      def notes
+        options[:notes].presence || loop do
+          answer = ask('Please add release notes:')
+          break answer if answer.present?
+        end
+      end
+
+      def build_package
+        zip_file = Tempfile.new(['connector', '.zip'])
+
+        ::Zip::OutputStream.open(zip_file.path) { |_| 'no-op' }
+        ::Zip::File.open(zip_file.path, ::Zip::File::CREATE) do |archive|
+          add_connector(archive)
+          add_manifest(archive)
+          add_logo(archive)
+        end
+
+        zip_file
+      end
+
+      def add_connector(archive)
+        archive.get_output_stream("#{PACKAGE_ENTRY_NAME}.rb") do |f|
+          f.write(File.read(options[:connector] || Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH))
+        end
+      end
+
+      def add_manifest(archive)
+        archive.get_output_stream("#{PACKAGE_ENTRY_NAME}.json") do |f|
+          f.write(JSON.pretty_generate(metadata))
+        end
+      end
+
+      def add_logo(archive)
+        return unless logo
+
+        archive.get_output_stream("#{PACKAGE_ENTRY_NAME}#{logo[:extname]}") do |f|
+          f.write(logo[:content])
+        end
+      end
+
+      def import_package(zip_file)
+        url = "#{api_base_url}#{API_IMPORT_PATH}/#{folder_id}"
+        response = RestClient.post(
+          url,
+          File.open(zip_file.path),
+          auth_headers.merge(
+            'Content-Type' => 'application/zip'
+          )
+        )
+        JSON.parse(response.body).fetch('id')
+      rescue RestClient::NotFound
+        raise "Can't find folder with ID=#{folder_id}"
+      rescue RestClient::BadRequest => e
+        message = JSON.parse(e.response.body).fetch('error')
+        raise "Failed to upload connector: #{message}"
+      end
+
+      def await_import(import_id)
+        url = "#{api_base_url}#{API_PACKAGE_PATH}/#{import_id}"
+        Timeout.timeout(AWAIT_IMPORT_TIMEOUT_INTERVAL) do
+          loop do
+            response = RestClient.get(url, auth_headers)
+
+            json = JSON.parse(response.body)
+            break json if json.fetch('status') != IMPORT_IN_PROGRESS
+
+            sleep(AWAIT_IMPORT_SLEEP_INTERVAL)
+          end
+        end
+      rescue Timeout::Error
+        raise 'Failed to wait import result. Go to Imports in Workato UI to see the push result'
+      end
+
+      def logo
+        return @logo if defined?(@logo)
+
+        path = (options.key?(:logo) && options[:logo]) ||
+               (File.exist?(DEFAULT_LOGO_PATH) && DEFAULT_LOGO_PATH)
+        return @logo = nil unless path
+
+        extname = File.extname(path).downcase
+        @logo = {
+          extname: extname,
+          content: File.read(path),
+          content_type: extname == '.png' ? 'image/png' : 'image/jpeg'
+        }
+      end
+
+      def metadata
+        {
+          title: title,
+          description: description,
+          note: notes
+        }.tap do |meta|
+          if logo
+            meta[:logo_file_name] = 'data'
+            meta[:logo_content_type] = logo[:content_type]
+          end
+        end
+      end
+
+      def title
+        options[:title].presence || connector.title.presence || loop do
+          answer = ask('Please provide title of the connector:')
+          break answer if answer.present?
+        end
+      end
+
+      def description
+        (options[:description].presence && File.read(options[:description])) ||
+          (File.exist?(DEFAULT_README_PATH) && File.read(DEFAULT_README_PATH)) ||
+          nil
+      end
+
+      def connector
+        @connector ||= Workato::Connector::Sdk::Connector.from_file(
+          options[:connector] || Workato::Connector::Sdk::DEFAULT_CONNECTOR_PATH
+        )
+      end
+
+      def auth_headers
+        {
+          'x-user-email' => api_email,
+          'x-user-token' => api_token
+        }
+      end
+
+      private_constant :IMPORT_IN_PROGRESS,
+                       :API_IMPORT_PATH,
+                       :API_PACKAGE_PATH,
+                       :PACKAGE_ENTRY_NAME,
+                       :AWAIT_IMPORT_SLEEP_INTERVAL,
+                       :AWAIT_IMPORT_TIMEOUT_INTERVAL
+    end
+  end
+end

data/lib/workato/connector/sdk/account_properties.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+require 'csv'
+require 'erb'
+require 'singleton'
+
+module Workato
+  module Connector
+    module Sdk
+      class AccountProperties
+        include Singleton
+
+        def self.from_yaml(path = DEFAULT_ACCOUNT_PROPERTIES_PATH)
+          File.open(path) do |f|
+            instance.load_data(YAML.safe_load(ERB.new(f.read).result, [::Symbol]).to_hash)
+          end
+        end
+
+        def self.from_encrypted_yaml(path = DEFAULT_ENCRYPTED_ACCOUNT_PROPERTIES_PATH, key_path = nil)
+          load_data(
+            ActiveSupport::EncryptedConfiguration.new(
+              config_path: path,
+              key_path: key_path || DEFAULT_MASTER_KEY_PATH,
+              env_key: DEFAULT_MASTER_KEY_ENV,
+              raise_if_missing_key: true
+            ).config
+          )
+        end
+
+        def self.from_csv(path = './account_properties.csv')
+          props = CSV.foreach(path, headers: true, return_headers: false).map do |row|
+            [row[0], row[1]]
+          end.to_h
+          instance.load_data(props)
+        end
+
+        class << self
+          delegate :load_data,
+                   :get,
+                   :put,
+                   to: :instance
+        end
+
+        def get(key)
+          @data ||= {}
+          @data[key.to_s]
+        end
+
+        def put(key, value)
+          @data ||= {}
+          @data[key.to_s] = value.to_s
+        end
+
+        def load_data(props = {})
+          props.each { |k, v| put(k, v) }
+        end
+      end
+    end
+  end
+end