zenaton 0.5.3 → 0.6.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b08187623f70606c27295f86be811f71dd80188db775074adb36525e7eb2c93c
-  data.tar.gz: 11656eb73d4e571e8603c403c40793904b3d94fb2d44c5a73791ea58ef874a86
+  metadata.gz: 3262580f994d9fab99ad54ad278b6f0f99611055a4b988dfd9049224cbb2ce52
+  data.tar.gz: 0df314ffedb3ed23d8e8753466bc5913453827bb1ed3cb05be068524819409db
 SHA512:
-  metadata.gz: 1b0004ca3a2e9791578af89aeb735d09062eedd5bd77fc4cf098abdae564526310b166e37e84f6e272ae9288f2fe0649fa6cf587499bf906e6c6969b0b75b90d
-  data.tar.gz: d94f70b29a3ff0b7f43bc5f38a0c00a05ebed2126439c08a50d202166d9670abc36e263f191b658f3d1472114c10322680de183caf15969638534aba62fbfe4a
+  metadata.gz: 430ccaed078e353fa8a5a3a102a9260f315fde7f50000b09edcb969561e5b4fec78e66471537c9fbe5dfbd032318cb8e9905fb0c0e4ea6d76f0912da79db261d
+  data.tar.gz: 06a0a71007724d2e0f052d2ca8345ca039770c97b31ac114ea42706f8ad1db456b7ac074cbe5a3904d435d37c4f086dfbfe64f2f7afeece12593633c1806b7a4

data/CHANGELOG.md

@@ -18,6 +18,18 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ### Security
 
+## [0.6.0] - 2019-10-02
+
+### Changed
+
+- `start workflow` now uses the graphql client
+- `start task` now uses the graphql client
+- `kill workflow` now uses the graphql client
+- `pause workflow` now uses the graphql client
+- `resume workflow` now uses the graphql client
+- `find workflow` now uses the graphql client
+
+
 ## [0.5.3] - 2019-10-02
 
 ### Added
@@ -37,6 +49,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 - Added missing documentation for serialization.
 - Added `custom_id` argument for workflow schedule.
 
+### Removed
+
+- Removed code from the client that pertained to the client mode
+
 ## [0.5.0] - 2019-08-27
 ### Changed
 - No longer load JSON core extensions. Use our own refinements to avoid clashes
@@ -137,7 +153,8 @@ available.
 ### Added
 - Initial release.
 
-[Unreleased]: https://github.com/zenaton/zenaton-ruby/compare/v0.5.3...HEAD
+[Unreleased]: https://github.com/zenaton/zenaton-ruby/compare/v0.6.0...HEAD
+[0.6.0]: https://github.com/zenaton/zenaton-ruby/compare/v0.5.3...v0.6.0
 [0.5.3]: https://github.com/zenaton/zenaton-ruby/compare/v0.5.2...v0.5.3
 [0.5.2]: https://github.com/zenaton/zenaton-ruby/compare/v0.5.1...v0.5.2
 [0.5.1]: https://github.com/zenaton/zenaton-ruby/compare/v0.5.0...v0.5.1

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    zenaton (0.5.3)
+    zenaton (0.6.0)
       activesupport
       tzinfo-data
 

data/lib/zenaton/client.rb

@@ -1,49 +1,22 @@
 # frozen_string_literal: true
 
-require 'securerandom'
 require 'singleton'
-require 'zenaton/services/graphql'
+require 'zenaton/services/graph_ql/client'
 require 'zenaton/services/http'
 require 'zenaton/services/properties'
 require 'zenaton/services/serializer'
-require 'zenaton/workflows/version'
 
 module Zenaton
   # Zenaton Client
   class Client
     include Singleton
 
-    ZENATON_API_URL = 'https://api.zenaton.com/v1' # Zenaton api url
-    ZENATON_GATEWAY_URL = 'https://gateway.zenaton.com/api' # Gateway url
     ZENATON_WORKER_URL = 'http://localhost' # Default worker url
     DEFAULT_WORKER_PORT = 4001 # Default worker port
     WORKER_API_VERSION = 'v_newton' # Default worker api version
 
-    MAX_ID_SIZE = 256 # Limit on length of custom ids
-
     APP_ENV = 'app_env' # Parameter name for the application environment
     APP_ID = 'app_id' # Parameter name for the application ID
-    API_TOKEN = 'api_token' # Parameter name for the API token
-
-    ATTR_INTENT_ID = 'intent_id' # Internal parameter for retries
-    ATTR_ID = 'custom_id' # Parameter name for custom ids
-    ATTR_NAME = 'name' # Parameter name for workflow names
-    ATTR_CANONICAL = 'canonical_name' # Parameter name for version name
-    ATTR_DATA = 'data' # Parameter name for json payload
-    ATTR_PROG = 'programming_language' # Parameter name for the language
-    ATTR_MODE = 'mode' # Parameter name for the worker update mode
-    # Parameter name for task maximum processing time
-    ATTR_MAX_PROCESSING_TIME = 'maxProcessingTime'
-
-    PROG = 'Ruby' # The current programming language
-
-    EVENT_INPUT = 'event_input' # Parameter name for event input
-    EVENT_NAME = 'event_name' # Parameter name for event name
-    EVENT_DATA = 'event_data' # Parameter name for event data
-
-    WORKFLOW_KILL = 'kill' # Worker update mode to stop a worker
-    WORKFLOW_PAUSE = 'pause' # Worker udpate mode to pause a worker
-    WORKFLOW_RUN = 'run' # Worker update mode to resume a worker
 
     attr_writer :app_id, :api_token, :app_env
 
@@ -63,7 +36,7 @@ module Zenaton
     # @private
     def initialize
       @http = Services::Http.new
-      @graphql = Services::GraphQL.new(http: @http)
+      @graphql = Services::GraphQL::Client.new(http: @http)
       @serializer = Services::Serializer.new
       @properties = Services::Properties.new
     end
@@ -84,133 +57,52 @@ module Zenaton
       end
     end
 
-    def gateway_url
-      ENV['ZENATON_GATEWAY_URL'] || ZENATON_GATEWAY_URL
-    end
-
-    def gateway_headers
-      {
-        'app-id' => @app_id,
-        'api-token' => @api_token
-      }
-    end
-
-    # Gets the url for zenaton api
-    # @param resource [String] the endpoint for the api
-    # @param params [Hash|String] query params to be url encoded
-    # @return [String] the api url with parameters
-    def website_url(resource = '', params = {})
-      api_url = ENV['ZENATON_API_URL'] || ZENATON_API_URL
-      url = "#{api_url}/#{resource}"
-
-      if params.is_a?(Hash)
-        params[API_TOKEN] = @api_token
-        append_params_to_url(url, params)
-      else
-        add_app_env("#{url}?#{API_TOKEN}=#{@api_token}&", params)
-      end
-    end
-
     # Start a single task
     # @param task [Zenaton::Interfaces::Task]
     def start_task(task)
-      max_processing_time = task.try(:max_processing_time)
-      @http.post(
-        worker_url('tasks'),
-        ATTR_INTENT_ID => SecureRandom.uuid,
-        ATTR_PROG => PROG,
-        ATTR_NAME => class_name(task),
-        ATTR_DATA => @serializer.encode(@properties.from(task)),
-        ATTR_MAX_PROCESSING_TIME => max_processing_time
-      )
+      @graphql.start_task(task, credentials)
     end
 
     # Start the specified workflow
     # @param flow [Zenaton::Interfaces::Workflow]
     def start_workflow(flow)
-      @http.post(
-        instance_worker_url,
-        ATTR_INTENT_ID => SecureRandom.uuid,
-        ATTR_PROG => PROG,
-        ATTR_CANONICAL => canonical_name(flow),
-        ATTR_NAME => class_name(flow),
-        ATTR_DATA => @serializer.encode(@properties.from(flow)),
-        ATTR_ID => parse_custom_id_from(flow)
-      )
+      @graphql.start_workflow(flow, credentials)
     end
 
+    # Schedule a task for repeated execution
     def start_scheduled_task(task, cron)
-      res = @graphql.request(
-        gateway_url,
-        Services::GraphQL::CREATE_TASK_SCHEDULE,
-        create_task_schedule_input(task, cron),
-        gateway_headers
-      )
+      res = @graphql.schedule_task(task, cron, credentials)
       res && res['createTaskSchedule']
     end
 
+    # Schedule a workflow for repeated execution
     def start_scheduled_workflow(flow, cron)
-      res = @graphql.request(
-        gateway_url,
-        Services::GraphQL::CREATE_WORKFLOW_SCHEDULE,
-        create_workflow_schedule_input(flow, cron),
-        gateway_headers
-      )
+      res = @graphql.schedule_workflow(flow, cron, credentials)
       res && res['createWorkflowSchedule']
     end
 
-    # rubocop:disable Metrics/MethodLength
-    def create_workflow_schedule_input(flow, cron)
-      {
-        'createWorkflowScheduleInput' => {
-          'intentId' => SecureRandom.uuid,
-          'environmentName' => @app_env,
-          'cron' => cron,
-          'customId' => parse_custom_id_from(flow),
-          'workflowName' => class_name(flow),
-          'canonicalName' => canonical_name(flow) || class_name(flow),
-          'programmingLanguage' => PROG.upcase,
-          'properties' => @serializer.encode(@properties.from(flow))
-        }
-      }
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def create_task_schedule_input(task, cron)
-      {
-        'createTaskScheduleInput' => {
-          'intentId' => SecureRandom.uuid,
-          'environmentName' => @app_env,
-          'cron' => cron,
-          'taskName' => class_name(task),
-          'programmingLanguage' => PROG.upcase,
-          'properties' => @serializer.encode(@properties.from(task))
-        }
-      }
-    end
-
     # Stops a workflow
-    # @param workflow_name [String] the class name of the workflow
-    # @param custom_id [String] the custom ID of the workflow (if any)
+    # @param name [String] the class name of the workflow
+    # @param custom_id [String] the custom ID of the workflow
     # @return [NilClass]
-    def kill_workflow(workflow_name, custom_id)
-      update_instance(workflow_name, custom_id, WORKFLOW_KILL)
+    def kill_workflow(name, custom_id)
+      @graphql.kill_workflow(name, custom_id, credentials)
     end
 
     # Pauses a workflow
-    # @param workflow_name [String] the class name of the workflow
-    # @param custom_id [String] the custom ID of the workflow (if any)
+    # @param name [String] the class name of the workflow
+    # @param custom_id [String] the custom ID of the workflow
     # @return [NilClass]
-    def pause_workflow(workflow_name, custom_id)
-      update_instance(workflow_name, custom_id, WORKFLOW_PAUSE)
+    def pause_workflow(name, custom_id)
+      @graphql.pause_workflow(name, custom_id, credentials)
     end
 
     # Resumes a workflow
-    # @param workflow_name [String] the class name of the workflow
-    # @param custom_id [String] the custom ID of the workflow (if any)
+    # @param name [String] the class name of the workflow
+    # @param custom_id [String] the custom ID of the workflow
     # @return [NilClass]
-    def resume_workflow(workflow_name, custom_id)
-      update_instance(workflow_name, custom_id, WORKFLOW_RUN)
+    def resume_workflow(name, custom_id)
+      @graphql.resume_workflow(name, custom_id, credentials)
     end
 
     # Finds a workflow
@@ -218,38 +110,28 @@ module Zenaton
     # @param custom_id [String] the custom ID of the workflow
     # @return [Zenaton::Interfaces::Workflow, nil]
     def find_workflow(workflow_name, custom_id)
-      params = { ATTR_ID => custom_id, ATTR_NAME => workflow_name }
-      params[ATTR_PROG] = PROG
-      data = @http.get(instance_website_url(params))['data']
-      data && @properties.object_from(
-        data['name'],
-        @serializer.decode(data['properties'])
-      )
-    rescue Zenaton::InternalError => exception
-      return nil if exception.message =~ /No workflow instance found/
-      raise exception
+      @graphql.find_workflow(workflow_name, custom_id, credentials)
     end
 
     # Sends an event to a workflow
     # @param workflow_name [String] the class name of the workflow
-    # @param custom_id [String] the custom ID of the workflow (if any)
+    # @param custom_id [String] the custom ID of the workflow
     # @param event [Zenaton::Interfaces::Event] the event to send
     # @return [NilClass]
     def send_event(workflow_name, custom_id, event)
-      body = {
-        ATTR_INTENT_ID => SecureRandom.uuid,
-        ATTR_PROG => PROG,
-        ATTR_NAME => workflow_name,
-        ATTR_ID => custom_id,
-        EVENT_NAME => event.class.name,
-        EVENT_INPUT => @serializer.encode(@properties.from(event)),
-        EVENT_DATA => @serializer.encode(event)
-      }
-      @http.post(send_event_url, body)
+      @graphql.send_event(workflow_name, custom_id, event, credentials)
     end
 
     private
 
+    def credentials
+      {
+        'app_id' => @app_id,
+        'api_token' => @api_token,
+        'app_env' => @app_env
+      }
+    end
+
     # DEPRECATED: This implementation does not safely encode the parameters to
     # be passed as query params in a get request. This method gets called by
     # agents up to version 0.4.5
@@ -272,56 +154,5 @@ module Zenaton
 
       "#{url}?#{URI.encode_www_form(params)}"
     end
-
-    def instance_website_url(params)
-      website_url('instances', params)
-    end
-
-    def instance_worker_url(params = {})
-      worker_url('instances', params)
-    end
-
-    def send_event_url
-      worker_url('events')
-    end
-
-    # rubocop:disable Metrics/MethodLength
-    def parse_custom_id_from(flow)
-      custom_id = flow.id
-      if custom_id
-        unless custom_id.is_a?(String) || custom_id.is_a?(Integer)
-          raise InvalidArgumentError,
-                'Provided ID must be a string or an integer'
-        end
-        custom_id = custom_id.to_s
-        if custom_id.length > MAX_ID_SIZE
-          raise InvalidArgumentError,
-                "Provided Id must not exceed #{MAX_ID_SIZE} bytes"
-        end
-      end
-      custom_id
-    end
-    # rubocop:enable Metrics/MethodLength
-
-    def canonical_name(flow)
-      flow.class.name if flow.is_a? Workflows::Version
-    end
-
-    def class_name(flow)
-      return flow.class.name unless flow.is_a? Workflows::Version
-      flow.current_implementation.class.name
-    end
-
-    def update_instance(workflow_name, custom_id, mode)
-      params = { ATTR_ID => custom_id }
-      url = instance_worker_url(params)
-      options = {
-        ATTR_INTENT_ID => SecureRandom.uuid,
-        ATTR_PROG => PROG,
-        ATTR_NAME => workflow_name,
-        ATTR_MODE => mode
-      }
-      @http.put(url, options)
-    end
   end
 end

data/lib/zenaton/concerns/workflow.rb

@@ -0,0 +1,54 @@
+# frozen_string_literal: true
+
+require 'active_support/concern'
+require 'zenaton/workflows/version'
+require 'zenaton/exceptions'
+
+module Zenaton
+  # Composable modules available for reuse
+  module Concerns
+    # Utility methods for classes that interact with workflows
+    # Requires an instance variable @workflow to work
+    module Workflow
+      extend ActiveSupport::Concern
+
+      MAX_ID_SIZE = 256 # Maximum length for custom ids
+
+      private
+
+      # Determines the name of the workflow
+      def workflow_name
+        if @workflow.is_a? Workflows::Version
+          @workflow.current_implementation.class.name
+        else
+          @workflow.class.name
+        end
+      end
+
+      # Validation for the return value of the [#id] method
+      def validate_custom_id
+        return unless @workflow.try(:id).present?
+
+        validate_custom_id_type
+        validate_custom_id_value
+      end
+
+      # Only allow String and Integers as custom IDs
+      def validate_custom_id_type
+        valid_types = [String, Integer]
+        return if valid_types.any? { |type| @workflow.id.is_a?(type) }
+
+        raise InvalidArgumentError,
+              'Provided ID must be a string or an integer' \
+      end
+
+      # Enforce maximum size on custom IDs
+      def validate_custom_id_value
+        return if @workflow.id.to_s.length <= MAX_ID_SIZE
+
+        raise InvalidArgumentError,
+              "Provided Id must not exceed #{MAX_ID_SIZE} bytes"
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/base_operation.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'securerandom'
+require 'zenaton/exceptions'
+require 'zenaton/services/properties'
+require 'zenaton/services/serializer'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # @abstract Superclass for graphql queries and mutations.
+      # It expects two methods to be implemented in children classes:
+      # - #body
+      # - #raw_query
+      class BaseOperation
+        # Sets up common dependencies for serialization
+        # Don't forget to call #super in your children #initialize if
+        # overriding this method.
+        def initialize(*)
+          @serializer = Services::Serializer.new
+          @properties = Services::Properties.new
+        end
+
+        # To be implemented in subclasses.
+        # Should return the body of the GraphQL request
+        # @raise [NotImplemented]
+        def body
+          raise NotImplemented
+        end
+
+        # To be implemented in subclasses.
+        # The actual GraphQL query
+        # @raise [NotImplemented]
+        def raw_query
+          raise NotImplemented
+        end
+
+        # Default implementation for parsing GraphQL responses
+        # Override in subclasses if needed.
+        # @raise [NotImplemented]
+        def result(response)
+          raise Zenaton::ExternalError, format_errors(response) \
+            if response['errors']
+
+          response['data']
+        end
+
+        # Removes duplicate white space from the raw_query
+        # @return [String]
+        def query
+          raw_query.gsub(/\s+/, ' ')
+        end
+
+        # Sets an unique identifier to the query
+        # @return [String]
+        def intent_id
+          SecureRandom.uuid
+        end
+
+        private
+
+        def format_errors(response)
+          response['errors'].map(&method(:format_error))
+                            .join("\n")
+        end
+
+        def format_error(error)
+          if error['path']
+            "- #{error['path']}: #{error['message']}"
+          else
+            "- #{error['message']}"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/client.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/create_workflow_schedule_mutation'
+require 'zenaton/services/graph_ql/create_task_schedule_mutation'
+require 'zenaton/services/graph_ql/dispatch_task_mutation'
+require 'zenaton/services/graph_ql/dispatch_workflow_mutation'
+require 'zenaton/services/graph_ql/kill_workflow_mutation'
+require 'zenaton/services/graph_ql/pause_workflow_mutation'
+require 'zenaton/services/graph_ql/resume_workflow_mutation'
+require 'zenaton/services/graph_ql/send_event_mutation'
+require 'zenaton/services/graph_ql/workflow_query'
+
+module Zenaton
+  module Services
+    # Module for client, mutations and queries used to communicate with
+    # Zenaton's GraphQL API
+    module GraphQL
+      # Small client to interact with Zenaton's GraphQL API
+      class Client
+        ZENATON_GATEWAY_URL = 'https://gateway.zenaton.com/api' # Gateway url
+
+        # Setup the GraphQL client with the HTTP client to use
+        def initialize(http:)
+          @http = http
+        end
+
+        # Scheduling a workflow
+        def schedule_workflow(workflow, cron, credentials)
+          app_env = credentials['app_env']
+          mutation = CreateWorkflowScheduleMutation.new(workflow, cron, app_env)
+          execute(mutation, credentials)
+        end
+
+        # Scheduling a task
+        def schedule_task(task, cron, credentials)
+          app_env = credentials['app_env']
+          mutation = CreateTaskScheduleMutation.new(task, cron, app_env)
+          execute(mutation, credentials)
+        end
+
+        # Dispatching a single task
+        def start_task(task, credentials)
+          app_env = credentials['app_env']
+          mutation = DispatchTaskMutation.new(task, app_env)
+          execute(mutation, credentials)
+        end
+
+        # Dispatching a workflow
+        def start_workflow(workflow, credentials)
+          app_env = credentials['app_env']
+          mutation = DispatchWorkflowMutation.new(workflow, app_env)
+          execute(mutation, credentials)
+        end
+
+        # Stopping an existing workflow
+        def kill_workflow(name, custom_id, credentials)
+          app_env = credentials['app_env']
+          mutation = KillWorkflowMutation.new(name, custom_id, app_env)
+          execute(mutation, credentials)
+        end
+
+        # Pausing an existing workflow
+        def pause_workflow(name, custom_id, credentials)
+          app_env = credentials['app_env']
+          mutation = PauseWorkflowMutation.new(name, custom_id, app_env)
+          execute(mutation, credentials)
+        end
+
+        # Resuming a paused workflow
+        def resume_workflow(name, custom_id, credentials)
+          app_env = credentials['app_env']
+          mutation = ResumeWorkflowMutation.new(name, custom_id, app_env)
+          execute(mutation, credentials)
+        end
+
+        # Sending an event to an existing workflow
+        def send_event(name, custom_id, event, credentials)
+          app_env = credentials['app_env']
+          mutation = SendEventMutation.new(name, custom_id, event, app_env)
+          execute(mutation, credentials)
+        end
+
+        # Search for a workflow with a custom ID
+        def find_workflow(name, custom_id, credentials)
+          app_env = credentials['app_env']
+          query = WorkflowQuery.new(name, custom_id, app_env)
+          execute(query, credentials)
+        end
+
+        private
+
+        def url
+          ENV['ZENATON_GATEWAY_URL'] || ZENATON_GATEWAY_URL
+        end
+
+        def headers(credentials)
+          {
+            'app-id' => credentials['app_id'],
+            'api-token' => credentials['api_token']
+          }
+        end
+
+        def execute(operation, credentials)
+          response = @http.post(url, operation.body, headers(credentials))
+          operation.result(response)
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/create_task_schedule_mutation.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Mutation parameters for scheduling a Task
+      class CreateTaskScheduleMutation < BaseOperation
+        def initialize(task, cron, app_env)
+          super
+          @task = task
+          @cron = cron
+          @app_env = app_env
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            mutation ($input: CreateTaskScheduleInput!) {
+              createTaskSchedule(input: $input) {
+                schedule {
+                  id
+                }
+              }
+            }
+          GQL
+        end
+
+        # The variables used in the query
+        def variables
+          {
+            'input' => {
+              'intentId' => intent_id,
+              'environmentName' => @app_env,
+              'cron' => @cron,
+              'taskName' => @task.class.name,
+              'programmingLanguage' => 'RUBY',
+              'properties' => @serializer.encode(@properties.from(@task))
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/create_workflow_schedule_mutation.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+require 'zenaton/concerns/workflow'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Mutation parameters for scheduling a Task
+      class CreateWorkflowScheduleMutation < BaseOperation
+        include Concerns::Workflow
+
+        # @raise [Zenaton::InvalidArgumentError] if custom id fails validation
+        def initialize(workflow, cron, app_env)
+          super
+          @workflow = workflow
+          @cron = cron
+          @app_env = app_env
+          validate_custom_id
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            mutation ($input: CreateWorkflowScheduleInput!) {
+              createWorkflowSchedule(input: $input) {
+                schedule {
+                  id
+                }
+              }
+            }
+          GQL
+        end
+
+        # The variables used in the query
+        def variables
+          { 'input' => input }
+        end
+
+        private
+
+        def input
+          {
+            'intentId' => intent_id,
+            'environmentName' => @app_env,
+            'cron' => @cron,
+            'customId' => @workflow.id.try(:to_s),
+            'workflowName' => workflow_name,
+            'canonicalName' => @workflow.class.name,
+            'programmingLanguage' => 'RUBY',
+            'properties' => @serializer.encode(@properties.from(@workflow))
+          }
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/dispatch_task_mutation.rb

@@ -0,0 +1,50 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Mutation parameters for executing a single task
+      class DispatchTaskMutation < BaseOperation
+        def initialize(task, app_env)
+          super
+          @task = task
+          @app_env = app_env
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            mutation dispatchTask($input: DispatchTaskInput!) {
+              dispatchTask(input: $input) {
+                task {
+                  intentId
+                }
+              }
+            }
+          GQL
+        end
+
+        # The variables used in the query
+        def variables
+          {
+            'input' => {
+              'environmentName' => @app_env,
+              'intentId' => intent_id,
+              'name' => @task.class.name,
+              'maxProcessingTime' => @task.try(:max_processing_time),
+              'programmingLanguage' => 'RUBY',
+              'data' => @serializer.encode(@properties.from(@task))
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/dispatch_workflow_mutation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+require 'zenaton/concerns/workflow'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Mutation parameters for executing a workflow
+      class DispatchWorkflowMutation < BaseOperation
+        include Concerns::Workflow
+
+        # @raise [Zenaton::InvalidArgumentError] if custom id fails validation
+        def initialize(workflow, app_env)
+          super
+          @workflow = workflow
+          @app_env = app_env
+          validate_custom_id
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            mutation dispatchWorkflow($input: DispatchWorkflowInput!) {
+              dispatchWorkflow(input: $input) {
+                workflow {
+                  id
+                }
+              }
+            }
+          GQL
+        end
+
+        # rubocop:disable Metrics/MethodLength
+        # The variables used in the query
+        def variables
+          {
+            'input' => {
+              'customId' => @workflow.id.try(:to_s),
+              'environmentName' => @app_env,
+              'intentId' => intent_id,
+              'programmingLanguage' => 'RUBY',
+              'name' => workflow_name,
+              'canonicalName' => @workflow.class.name,
+              'data' => @serializer.encode(@properties.from(@workflow))
+            }
+          }
+        end
+        # rubocop:enable Metrics/MethodLength
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/kill_workflow_mutation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Mutation parameters for stopping a workflow
+      class KillWorkflowMutation < BaseOperation
+        def initialize(name, custom_id, app_env)
+          super
+          @name = name
+          @custom_id = custom_id
+          @app_env = app_env
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            mutation killWorkflow($input: KillWorkflowInput!) {
+              killWorkflow(input: $input) {
+                id
+              }
+            }
+          GQL
+        end
+
+        # The variables used in the query
+        def variables
+          {
+            'input' => {
+              'customId' => @custom_id,
+              'environmentName' => @app_env,
+              'intentId' => intent_id,
+              'programmingLanguage' => 'RUBY',
+              'name' => @name
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/pause_workflow_mutation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Mutation parameters for pausing a Workflow
+      class PauseWorkflowMutation < BaseOperation
+        def initialize(name, custom_id, app_env)
+          super
+          @name = name
+          @custom_id = custom_id
+          @app_env = app_env
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            mutation pauseWorkflow($input: PauseWorkflowInput!) {
+              pauseWorkflow(input: $input) {
+                id
+              }
+            }
+          GQL
+        end
+
+        # The variables used in the query
+        def variables
+          {
+            'input' => {
+              'customId' => @custom_id,
+              'environmentName' => @app_env,
+              'intentId' => intent_id,
+              'programmingLanguage' => 'RUBY',
+              'name' => @name
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/resume_workflow_mutation.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Mutation parameters for resuming a paused Workflow
+      class ResumeWorkflowMutation < BaseOperation
+        def initialize(name, custom_id, app_env)
+          super
+          @name = name
+          @custom_id = custom_id
+          @app_env = app_env
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            mutation resumeWorkflow($input: ResumeWorkflowInput!) {
+              resumeWorkflow(input: $input) {
+                id
+              }
+            }
+          GQL
+        end
+
+        # The variables used in the query
+        def variables
+          {
+            'input' => {
+              'customId' => @custom_id,
+              'environmentName' => @app_env,
+              'intentId' => intent_id,
+              'programmingLanguage' => 'RUBY',
+              'name' => @name
+            }
+          }
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/send_event_mutation.rb

@@ -0,0 +1,58 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Mutation parameters for sending an Event to a Workflow
+      class SendEventMutation < BaseOperation
+        def initialize(name, custom_id, event, app_env)
+          super
+          @workflow_name = name
+          @custom_id = custom_id
+          @event = event
+          @app_env = app_env
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            mutation sendEventToWorkflowByNameAndCustomId($input: SendEventToWorkflowByNameAndCustomIdInput!) {
+              sendEventToWorkflowByNameAndCustomId(input: $input) {
+                event {
+                  intentId
+                }
+              }
+            }
+          GQL
+        end
+
+        # The variables used in the query
+        def variables
+          { 'input' => input }
+        end
+
+        private
+
+        def input
+          {
+            'customId' => @custom_id,
+            'workflowName' => @workflow_name,
+            'name' => @event.class.name,
+            'environmentName' => @app_env,
+            'intentId' => intent_id,
+            'programmingLanguage' => 'RUBY',
+            'input' => @serializer.encode(@properties.from(@event)),
+            'data' => @serializer.encode(@event)
+          }
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/services/graph_ql/workflow_query.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'zenaton/services/graph_ql/base_operation'
+
+module Zenaton
+  module Services
+    module GraphQL
+      # Query parameters to search for a Workflow
+      class WorkflowQuery < BaseOperation
+        def initialize(workflow_name, custom_id, app_env)
+          super
+          @workflow_name = workflow_name
+          @custom_id = custom_id
+          @app_env = app_env
+        end
+
+        # The body of the GraphQL request
+        def body
+          { 'query' => query, 'variables' => variables }
+        end
+
+        # The query to be executed
+        def raw_query
+          <<~GQL
+            query ($workflowName: String, $customId: ID, $environmentName: String, $programmingLanguage: String) {
+              findWorkflow(environmentName: $environmentName, programmingLanguage: $programmingLanguage, customId: $customId, name: $workflowName) {
+                name
+                properties
+              }
+            }
+          GQL
+        end
+
+        # The variables used in the query
+        def variables
+          {
+            'customId' => @custom_id,
+            'environmentName' => @app_env,
+            'programmingLanguage' => 'RUBY',
+            'workflowName' => @workflow_name
+          }
+        end
+
+        # Parses the results of the query
+        def result(response)
+          data = response['data']
+          raise Zenaton::ExternalError, format_errors(response) unless data
+
+          return nil if data['findWorkflow'].nil?
+
+          @properties.object_from(
+            data['findWorkflow']['name'],
+            @serializer.decode(data['findWorkflow']['properties'])
+          )
+        end
+      end
+    end
+  end
+end

data/lib/zenaton/traits/zenatonable.rb

@@ -22,6 +22,7 @@ module Zenaton
         Engine.instance.dispatch([self])
       end
 
+      # Sets the repeatable frequency of execution of a given job
       def schedule(cron)
         if !cron.is_a?(String) || cron.blank?
           raise InvalidArgumentError,

data/lib/zenaton/version.rb

@@ -2,5 +2,5 @@
 
 module Zenaton
   # This gem's current version
-  VERSION = '0.5.3'
+  VERSION = '0.6.0'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: zenaton
 version: !ruby/object:Gem::Version
-  version: 0.5.3
+  version: 0.6.0
 platform: ruby
 authors:
 - Zenaton
@@ -234,6 +234,7 @@ files:
 - gemfiles/rails_5.2.gemfile
 - lib/zenaton.rb
 - lib/zenaton/client.rb
+- lib/zenaton/concerns/workflow.rb
 - lib/zenaton/contexts.rb
 - lib/zenaton/contexts/task.rb
 - lib/zenaton/contexts/workflow.rb
@@ -261,7 +262,17 @@ files:
 - lib/zenaton/refinements/struct.rb
 - lib/zenaton/refinements/symbol.rb
 - lib/zenaton/refinements/time.rb
-- lib/zenaton/services/graphql.rb
+- lib/zenaton/services/graph_ql/base_operation.rb
+- lib/zenaton/services/graph_ql/client.rb
+- lib/zenaton/services/graph_ql/create_task_schedule_mutation.rb
+- lib/zenaton/services/graph_ql/create_workflow_schedule_mutation.rb
+- lib/zenaton/services/graph_ql/dispatch_task_mutation.rb
+- lib/zenaton/services/graph_ql/dispatch_workflow_mutation.rb
+- lib/zenaton/services/graph_ql/kill_workflow_mutation.rb
+- lib/zenaton/services/graph_ql/pause_workflow_mutation.rb
+- lib/zenaton/services/graph_ql/resume_workflow_mutation.rb
+- lib/zenaton/services/graph_ql/send_event_mutation.rb
+- lib/zenaton/services/graph_ql/workflow_query.rb
 - lib/zenaton/services/http.rb
 - lib/zenaton/services/properties.rb
 - lib/zenaton/services/serializer.rb

data/lib/zenaton/services/graphql.rb

@@ -1,71 +0,0 @@
-# frozen_string_literal: true
-
-require 'zenaton/exceptions'
-
-module Zenaton
-  # Collection of utility classes for the Zenaton library
-  module Services
-    # Service that:
-    # - handles graphql calls
-    # - translates exceptions into Zenaton specific ones
-    class GraphQL
-      CREATE_WORKFLOW_SCHEDULE = <<-'GRAPHQL'
-        mutation ($createWorkflowScheduleInput: CreateWorkflowScheduleInput!) {
-          createWorkflowSchedule(input: $createWorkflowScheduleInput) {
-            schedule {
-              id
-            }
-          }
-        }
-      GRAPHQL
-
-      CREATE_TASK_SCHEDULE = <<-'GRAPHQL'
-        mutation ($createTaskScheduleInput: CreateTaskScheduleInput!) {
-          createTaskSchedule(input: $createTaskScheduleInput) {
-            schedule {
-              id
-            }
-          }
-        }
-      GRAPHQL
-
-      def initialize(http:)
-        @http = http
-      end
-
-      # Makes a GRAPHQL request with some data and sets the correct headers
-      #
-      # @param url [String] the url for the request
-      # @param body [Hash] the payload to send with the request
-      # @return [Hash] the parsed json response
-      def request(url, query, variables = nil, headers = {})
-        body = { 'query' => query }
-        body['variables'] = variables if variables
-
-        res_body = @http.post(url, body, headers)
-        handle_response_body(res_body)
-      end
-
-      private
-
-      def handle_response_body(response_body)
-        if external_error?(response_body)
-          raise Zenaton::ExternalError, format_external_error(response_body)
-        end
-
-        response_body && response_body['data']
-      end
-
-      def external_error?(response_body)
-        response_body&.key?('errors')
-      end
-
-      def format_external_error(response_body)
-        response_body['errors'].map do |error|
-          path = error['path'] ? "- #{error['path']}: " : ''
-          "#{path}#{error['message']}"
-        end.join("\n")
-      end
-    end
-  end
-end