mirah-ruby 0.1.0

data/Rakefile

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+require 'graphql/client'
+require 'graphql/client/http'
+
+task :dump_schema do
+  http = GraphQL::Client::HTTP.new('http://localhost:3000/integration_api/graphqlschema')
+  ::GraphQL::Client.dump_schema(http, 'schema.json')
+end
+
+# Run by typing: rake yard
+
+PATH = File.dirname(__FILE__)
+
+require 'yard'
+
+YARD::Rake::YardocTask.new

data/bin/autocorrect

@@ -0,0 +1,28 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'yaml'
+
+config = YAML.load_file('.rubocop.yml')
+
+# Check if the file is excluded from all cops
+exclude_file = lambda do |file|
+  config['AllCops']['Exclude'].any? do |pattern|
+    File.fnmatch(pattern, file, File::FNM_PATHNAME)
+  end
+end
+
+files = `git diff --name-only --diff-filter=ACMR --ignore-submodules=all --staged`
+        .split(/\n/)
+        .reject(&exclude_file)
+
+if files.empty?
+  puts 'There is nothing staged to correct!'
+  exit
+end
+
+system({ 'BUNDLE_GEMFILE' => '.overcommit_gems.rb' },
+       "bundle exec rubocop --auto-correct --config=.rubocop.yml #{files.join(' ')}")
+
+puts
+puts 'Corrections applied. Review unstaged changes and apply any required manual corrections.'

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "mirah"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/bin/setup_overcommit

@@ -0,0 +1,12 @@
+#!/usr/bin/env ruby
+require 'pathname'
+
+# path to your application root.
+APP_ROOT = Pathname.new File.expand_path('../../',  __FILE__)
+
+Dir.chdir APP_ROOT do
+  puts "== Installing overcommit =="
+  system({"BUNDLE_GEMFILE" => ".overcommit_gems.rb"}, "bundle check || bundle install")
+  system({"BUNDLE_GEMFILE" => ".overcommit_gems.rb"}, "bundle exec overcommit --install")
+  system({"BUNDLE_GEMFILE" => ".overcommit_gems.rb"}, "bundle exec overcommit --sign")
+end

data/lib/mirah.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'date'
+
+require 'graphql/client'
+require 'graphql/client/http'
+
+require 'active_support/hash_with_indifferent_access'
+require 'active_support/inflector'
+
+require 'mirah/version'
+require 'mirah/errors'
+require 'mirah/serializers'
+require 'mirah/base_object'
+require 'mirah/collection'
+require 'mirah/push_result'
+require 'mirah/graphql'
+
+Dir[File.dirname(__FILE__) + '/mirah/data/**/*.rb'].sort.each do |file|
+  require file
+end
+
+require 'mirah/graphql/fragments'
+require 'mirah/graphql/queries'
+require 'mirah/graphql/mutations'
+
+require 'mirah/filters'
+
+Dir[File.dirname(__FILE__) + '/mirah/filters/**/*.rb'].sort.each do |file|
+  require file
+end
+
+require 'mirah/inputs'
+require 'mirah/base_input_object'
+
+Dir[File.dirname(__FILE__) + '/mirah/inputs/**/*.rb'].sort.each do |file|
+  require file
+end
+
+require 'mirah/client'
+
+# Mirah ruby interoperability
+module Mirah
+end

data/lib/mirah/base_input_object.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+module Mirah
+  # This object provides a DSL by which you can easy create plain ruby objects with `attr_accessor` that will
+  # automatically be transformed back and forth from a GraphQL endpoint. This includes changing the format of the
+  # key from `ruby_style` to `graphqlStyle` and back again, and extra serialization where necessary for scalar types
+  # such as dates.
+  class BaseInputObject
+    def initialize(attrs = {})
+      attrs.each do |key, value|
+        raise Errors::InvalidParameter.new(key), "#{key} is not a valid parameter" unless respond_to? "#{key}="
+
+        send("#{key}=", value)
+      end
+    end
+
+    def valid?
+      self.class.inputs.all? do |input|
+        !input[:required] || send(input[:name])
+      end
+    end
+
+    def validate!
+      self.class.inputs.all? do |input|
+        if input[:required] && !send(input[:name])
+          raise Errors::MissingParameter.new(input[:name]), "#{input[:name]} is missing"
+        end
+      end
+    end
+
+    def to_graphql_hash
+      self.class.inputs.each_with_object({}) do |input, obj|
+        value = input[:serializer].serialize(send(input[:name]))
+        obj[input[:graphql_name]] = value if value
+      end
+    end
+
+    def self.from_graphql_hash(graphql_data)
+      return nil unless graphql_data
+
+      attrs = inputs.each_with_object({}) do |input, obj|
+        value = graphql_data[input[:graphql_name]]
+        obj[input[:name]] = input[:serializer].deserialize(value)
+      end
+
+      new(attrs)
+    end
+
+    # @private
+    def self.inputs
+      @inputs ||= []
+    end
+
+    # @private
+    def self.input(name, required:, serializer: Serializers::ScalarSerializer)
+      inputs.push(
+        { name: name,
+          serializer: serializer,
+          required: required,
+          graphql_name: name.to_s.camelize(:lower) }
+      )
+      attr_accessor name
+    end
+  end
+end

data/lib/mirah/base_object.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Mirah
+  # This object provides a DSL by which you can easy create plain ruby objects with `attr_accessor` that will
+  # automatically be transformed back and forth from a GraphQL endpoint. This includes changing the format of the
+  # key from `ruby_style` to `graphqlStyle` and back again, and extra serialization where necessary for scalar types
+  # such as dates.
+  class BaseObject
+    def initialize(attrs = {})
+      attrs.each do |key, value|
+        send("#{key}=", value)
+      end
+    end
+
+    def to_graphql_hash
+      self.class.attributes.each_with_object({}) do |attribute, obj|
+        value = attribute[:serializer].serialize(send(attribute[:name]))
+        write_value(obj, value, attribute)
+      end
+    end
+
+    def self.from_graphql_hash(graphql_data)
+      return nil unless graphql_data
+
+      attrs = attributes.each_with_object({}) do |attribute, obj|
+        value = read_value(graphql_data, attribute)
+        obj[attribute[:name]] = attribute[:serializer].deserialize(value)
+      end
+
+      new(attrs)
+    end
+
+    # @private
+    def self.attributes
+      @attributes ||= []
+    end
+
+    # @private
+    def self.attribute(name, serializer: Serializers::ScalarSerializer, target: name, path: nil)
+      attributes.push(
+        {
+          name: name,
+          serializer: serializer,
+          path: path,
+          graphql_name: target.to_s.camelize(:lower)
+        }
+      )
+      attr_accessor name
+    end
+
+    private
+
+    def write_value(object, value, attribute)
+      object_to_write = object
+
+      object_to_write = write_nested_value(object, attribute[:path].dup) if attribute[:path]
+
+      object_to_write[attribute[:graphql_name]] = value if value
+    end
+
+    def write_nested_value(object, path)
+      current_obj = object
+
+      loop do
+        path_part = path.shift
+        current_obj[path_part] ||= {}
+        current_obj = current_obj[path_part]
+        break current_obj unless path&.length&.positive?
+      end
+    end
+
+    class << self
+      private
+
+      def read_value(graphql_data, attribute)
+        if attribute[:path]
+          read_nested_path(graphql_data, attribute[:path].dup, attribute[:graphql_name])
+        elsif graphql_data
+          graphql_data[attribute[:graphql_name]]
+        end
+      end
+
+      def read_nested_path(data, path, target)
+        return data[target] unless path&.length&.positive?
+
+        new_data = data[path.shift]
+
+        return nil unless new_data
+
+        if new_data.is_a? Array
+          new_data.map { |item| read_nested_path(item, path, target) }
+        else
+          read_nested_path(new_data, path, target)
+        end
+      end
+    end
+  end
+end

data/lib/mirah/client.rb

@@ -0,0 +1,420 @@
+# frozen_string_literal: true
+
+module Mirah
+  # A client designed to communicate with the Mirah system in a constrained set of well defined ways.
+  # This is a front to the more general Graphql backend which is available.
+  #
+  # == Patient Methods
+  # * {find_patient}
+  # * {find_patient_by_external_id}
+  # * {query_patients}
+  # * {push_patient}
+  #
+  # == Organization Methods
+  # * {find_organization}
+  # * {find_organization_by_external_id}
+  # * {query_organizations}
+  # * {push_organization}
+  #
+  # == Practitioner Methods
+  # * {find_practitioner}
+  # * {find_practitioner_by_external_id}
+  # * {query_practitioners}
+  # * {push_practitioner}
+  #
+  # == Appointment Methods
+  # * {find_appointment}
+  # * {find_appointment_by_external_id}
+  # * {query_appointments}
+  # * {push_appointment}
+  #
+  # @example
+  #   # Create a new client
+  #   client = Mirah::Client.new(host: 'https://api.mirah.com', user_id: 'my_user_id', access_token: 'my_token')
+  #
+  #   # find a patient
+  #   client.find_patient_by_external_id('mrn0001')
+  class Client # rubocop:disable Metrics/ClassLength
+    # Construct a new Client with the given host and credentials.
+    # @param host [String] The host, e.g. 'https://api.mirah.com'
+    # @param user_id [String] Your user id
+    # @param access_token [String] Your secret API token.
+    def initialize(host:, user_id:, access_token:)
+      @client = Graphql.create_client(host: host)
+      @client_context = { user_id: user_id, access_token: access_token }
+    end
+
+    # Access to the underlying graphql client. You may use this for advanced queries that are not provided
+    # as part of the standard library.
+    attr_reader :client
+
+    #################################################################################################################
+    # PATIENT METHODS
+    #################################################################################################################
+
+    # Find a patient by the given Mirah internal UUID. This method should be used if you already know the Mirah
+    # identifier. If you wish to query by your own system identifier, you should use {#find_patient_by_external_id}
+    #
+    # @since 0.1.0
+    # @param id [String] Mirah UUID for the patient
+    # @return [Data::Patient, nil] the patient, or nil if the record does not exist.
+    def find_patient(id)
+      query_record(Graphql::Queries::PatientIdQuery, id, Data::Patient, 'patient')
+    end
+
+    # Find a patient by your external id. This is a convenience method. If you wish to query a list of patients
+    # by external id, please use {Client#query_patients}.
+    #
+    # @since 0.1.0
+    # @param external_id [String] The identifier of the system of record
+    # @return [Data::Patient, nil] the patient, or nil if the record does not exist.
+    def find_patient_by_external_id(external_id)
+      query_record_by_external_id(Graphql::Queries::PatientExternalIdQuery,
+                                  external_id,
+                                  Data::Patient,
+                                  'patientExternal')
+    end
+
+    # Query for patients. You may specify a set of parameters as defined in {Mirah::Filters::PatientFilters}.
+    # Results are returned in a paginated format. See {Collection} for how to page results.
+    #
+    # @since 0.1.0
+    # @param external_id [Array<String>] See {Mirah::Filters::PatientFilters#external_id}
+    # @param search [String] See {Mirah::Filters::PatientFilters#search}
+    # @return [Collection<Data::Patient>] a collection of pageable patients.
+    def query_patients(external_id: nil, search: nil)
+      query_connection(
+        Graphql::Queries::PatientQuery,
+        Filters::PatientFilters.new(external_id: external_id, search: search),
+        Filters::Paging.default,
+        Data::Patient,
+        'patients'
+      )
+    end
+
+    # Create or update a patient. You must specify an external identifier, all other parameters are optional,
+    # but you may receive errors if you attempt to specify too few parameters for a patient that does not exist.
+    #
+    # @since 0.1.0
+    # @param external_id [String] the external identifier for this patient
+    # @option input_values [String, nil] :given_name see {Data::Patient#given_name}
+    # @option input_values [String, nil] :family_name see {Data::Patient#family_name}
+    # @option input_values [Date, nil] :birth_date see {Data::Patient#birth_date}
+    # @option input_values [String, nil] :gender see {Data::Patient#gender}
+    # @option input_values [String, nil] :primary_language see {Data::Patient#primary_language}
+    # @option input_values [String, nil] :email see {Data::Patient#email}
+    # @option input_values [String, nil] :phone_number see {Data::Patient#phone_number}
+    # @return [PushResult<Data::Patient>] the operation result with a patient on success
+    def push_patient(external_id:, **input_values)
+      mutate(Graphql::Mutations::CreateOrUpdatePatientMutation,
+             Inputs::PatientInput.new(input_values.merge(external_id: external_id)),
+             Data::Patient, 'createOrUpdatePatient')
+    end
+
+    #################################################################################################################
+    # ORGANIZATION METHODS
+    #################################################################################################################
+
+    # Find an organization by the given Mirah internal UUID. This method should be used if you already know the Mirah
+    # identifier. If you wish to query by your own system identifier, you should use {#find_organization_by_external_id}
+    #
+    # @since 0.1.0
+    # @param id [String] Mirah UUID for the organization
+    # @return [Data::Organization, nil] the organization, or nil if the record does not exist.
+    def find_organization(id)
+      query_record(Graphql::Queries::OrganizationIdQuery, id, Data::Organization, 'organization')
+    end
+
+    # Find an organization by your external id. This is a convenience method. If you wish to query a list of
+    # organizations by external id, please use {Client#query_organizations}.
+    #
+    # @since 0.1.0
+    # @param external_id [String] The identifier of the system of record
+    # @return [Data::Organization, nil] the organization, or nil if the record does not exist.
+    def find_organization_by_external_id(external_id)
+      query_record_by_external_id(Graphql::Queries::OrganizationExternalIdQuery,
+                                  external_id,
+                                  Data::Organization,
+                                  'organizationExternal')
+    end
+
+    # Query for organizations. You may specify a set of parameters as defined in {Mirah::Filters::OrganizationFilters}.
+    # Results are returned in a paginated format. See {Collection} for how to page results.
+
+    # @since 0.1.0
+    # @param external_id [Array<String>] See {Mirah::Filters::OrganizationFilters#external_id}
+    # @param search [String] See {Mirah::Filters::OrganizationFilters#search}
+    # @return [Collection<Data::Organization>] a collection of pageable organizations.
+    def query_organizations(external_id: nil, search: nil)
+      query_connection(
+        Graphql::Queries::OrganizationQuery,
+        Filters::OrganizationFilters.new(external_id: external_id, search: search),
+        Filters::Paging.default,
+        Data::Organization,
+        'organizations'
+      )
+    end
+
+    # Create or update an organization. You must specify an external identifier, all other parameters are optional,
+    # but you may receive errors if you attempt to specify too few parameters for an organization that does not exist.
+    #
+    # @since 0.1.0
+    # @param external_id [String] the external identifier for this organization
+    # @option input_values [String, nil] :name see {Data::Organization#name}
+    # @option input_values [String, nil] :external_part_of_id The external identifier for the parent organization
+    # @return [PushResult<Data::Organization>] the operation result with the organization on success
+    def push_organization(external_id:, **input_values)
+      mutate(Graphql::Mutations::CreateOrUpdateOrganizationMutation,
+             Inputs::OrganizationInput.new(input_values.merge(external_id: external_id)),
+             Data::Organization, 'createOrUpdateOrganization')
+    end
+
+    #################################################################################################################
+    # PRACTITIONER METHODS
+    #################################################################################################################
+
+    # Find an practitioner by the given Mirah internal UUID. This method should be used if you already know the Mirah
+    # identifier. If you wish to query by your own system identifier, you should use {#find_practitioner_by_external_id}
+    #
+    # @since 0.1.0
+    # @param id [String] Mirah UUID for the practitioner
+    # @return [Data::Practitioner, nil] the practitioner, or nil if the record does not exist.
+    def find_practitioner(id)
+      query_record(Graphql::Queries::PractitionerIdQuery, id, Data::Practitioner, 'practitioner')
+    end
+
+    # Find an practitioner by your external id. This is a convenience method. If you wish to query a list of
+    # practitioners by external id, please use {Client#query_practitioners}.
+    #
+    # @since 0.1.0
+    # @param external_id [String] The identifier of the system of record
+    # @return [Data::Practitioner, nil] the practitioner, or nil if the record does not exist.
+    def find_practitioner_by_external_id(external_id)
+      query_record_by_external_id(Graphql::Queries::PractitionerExternalIdQuery,
+                                  external_id,
+                                  Data::Practitioner,
+                                  'practitionerExternal')
+    end
+
+    # Query for practitioners. You may specify a set of parameters as defined in {Mirah::Filters::PractitionerFilters}.
+    # Results are returned in a paginated format. See {Collection} for how to page results.
+    #
+    # @since 0.1.0
+    # @param external_id [String] See {Mirah::Filters::PractitionerFilters#external_id}
+    # @param search [String] See {Mirah::Filters::PractitionerFilters#search}
+    # @return [Collection<Data::Practitioner>] a collection of pageable practitioners.
+    def query_practitioners(external_id: nil, search: nil)
+      query_connection(
+        Graphql::Queries::PractitionerQuery,
+        Filters::PractitionerFilters.new(external_id: external_id, search: search),
+        Filters::Paging.default,
+        Data::Practitioner,
+        'practitioners'
+      )
+    end
+
+    # Create or update an practitioner. You must specify an external identifier, all other parameters are optional,
+    # but you may receive errors if you attempt to specify too few parameters for an practitioner that does not exist.
+    #
+    # @since 0.1.0
+    # @param external_id [String] the external identifier for this practitioner
+    # @option input_values [String, nil] :given_name see {Data::Practitioner#given_name}
+    # @option input_values [String, nil] :family_name see {Data::Practitioner#family_name}
+    # @option input_values [String, nil] :title see {Data::Practitioner#title}
+    # @option input_values [String, nil] :suffix see {Data::Practitioner#suffix}
+    # @option input_values [String, nil] :email see {Data::Practitioner#email}
+    # @option input_values [String, nil] :default_practitioner_role see {Data::Practitioner#default_practitioner_role}
+    # @option input_values [String, nil] :sso_username see {Data::Practitioner#sso_username}
+    # @option input_values [Array<String>, nil] :external_organization_ids see
+    #                                           {Data::Practitioner#external_organization_ids}
+    # @return [PushResult<Data::Practitioner>] the operation result with the practitioner on success
+    def push_practitioner(external_id:, **input_values)
+      mutate(Graphql::Mutations::CreateOrUpdatePractitionerMutation,
+             Inputs::PractitionerInput.new(input_values.merge(external_id: external_id)),
+             Data::Practitioner, 'createOrUpdatePractitioner')
+    end
+
+    #################################################################################################################
+    # APPOINTMENT METHODS
+    #################################################################################################################
+
+    # Find an appointment by the given Mirah internal UUID. This method should be used if you already know the Mirah
+    # identifier. If you wish to query by your own system identifier, you should use {#find_appointment_by_external_id}
+    #
+    # @since 0.1.0
+    # @param id [String] Mirah UUID for the appointment
+    # @return [Data::Appointment, nil] the appointment, or nil if the record does not exist.
+    def find_appointment(id)
+      query_record(Graphql::Queries::AppointmentIdQuery, id, Data::Appointment, 'appointment')
+    end
+
+    # Find an appointment by your external id. This is a convenience method. If you wish to query a list of
+    # appointments by external id, please use {Client#query_appointments}.
+    #
+    # @since 0.1.0
+    # @param external_id [String] The identifier of the system of record
+    # @return [Data::Appointment, nil] the appointment, or nil if the record does not exist.
+    def find_appointment_by_external_id(external_id)
+      query_record_by_external_id(Graphql::Queries::AppointmentExternalIdQuery,
+                                  external_id,
+                                  Data::Appointment,
+                                  'appointmentExternal')
+    end
+
+    # Query for appointments. You may specify a set of parameters as defined in {Mirah::Filters::AppointmentFilters}.
+    # Results are returned in a paginated format. See {Collection} for how to page results.
+
+    # @since 0.1.0
+    # @param external_id [Array<String>] See {Mirah::Filters::AppointmentFilters#external_id}
+    # @param status [String] See {Mirah::Filters::AppointmentFilters#external_id}
+    # @return [Collection<Data::Appointment>] a collection of pageable appointments.
+    def query_appointments(external_id: nil, status: nil)
+      query_connection(
+        Graphql::Queries::AppointmentQuery,
+        Filters::AppointmentFilters.new(external_id: external_id, status: status),
+        Filters::Paging.default,
+        Data::Appointment,
+        'appointments'
+      )
+    end
+
+    # Create or update an appointment. You must specify an external identifier, all other parameters are optional,
+    # but you may receive errors if you attempt to specify too few parameters for an appointment that does not exist.
+    #
+    # @since 0.1.0
+    # @param external_id [String] the external identifier for this appointment
+    # @param status [String] the status identifier of this appointment, see {Data::Appointment#status}
+    # @option input_values [String, nil] :start_date see {Data::Appointment#start_date}
+    # @option input_values [String, nil] :end_date see {Data::Appointment#end_date}
+    # @option input_values [String, nil] :minutes_duration see {Data::Appointment#minutes_duration}
+    # @option input_values [String, nil] :patient_id see {Data::Appointment#patient_id}
+    # @option input_values [String, nil] :external_patient_id see {Data::Appointment#external_patient_id}
+    # @option input_values [String, nil] :practitioner_id see {Data::Appointment#practitioner_id}
+    # @option input_values [String, nil] :external_practitioner_id see {Data::Appointment#external_practitioner_id}
+    # @option input_values [String, nil] :organization_id see {Data::Appointment#organization_id}
+    # @option input_values [String, nil] :external_organization_id see {Data::Appointment#external_organization_id}
+    # @return [PushResult<Data::Appointment>] the operation result with the appointment on success
+    def push_appointment(external_id:, status:, **input_values)
+      mutate(Graphql::Mutations::CreateOrUpdateAppointmentMutation,
+             Inputs::AppointmentInput.new(input_values.merge(external_id: external_id, status: status)),
+             Data::Appointment, 'createOrUpdateAppointment')
+    end
+
+    ##################################################################################################################
+    # Internal methods
+    ##################################################################################################################
+
+    # This is technically a public method so that collections can get the next page, but should not generally
+    # be invoked directly otherwise.
+    # @private
+    def query_connection(query, input, paging, data_klass, path)
+      variables = input.to_graphql_hash.merge(paging.to_graphql_hash)
+      response = client.query(query, variables: variables, context: client_context)
+      check_response_for_errors(response)
+
+      response_json = response.to_h
+      results = parse_graphql_connection_response(response_json, data_klass, path, 'nodes')
+      page_info = parse_page_info(response_json, path)
+
+      # Used to generate subsequent pages
+      query_details = { query: query, input: input, paging: paging, data_klass: data_klass, path: path }
+      Collection.new(results: results, page_info: page_info, client: self, query: query_details)
+    rescue StandardError => e
+      handle_errors(e)
+    end
+
+    private
+
+    attr_reader :client_context
+
+    def query_record(query, id, data_klass, path)
+      response = client.query(query, variables: { id: id }, context: client_context)
+      check_response_for_errors(response)
+      response_json = response.to_h
+
+      parse_graphql_response(response_json, data_klass, path)
+    rescue StandardError => e
+      handle_errors(e)
+    end
+
+    def query_record_by_external_id(query, external_id, data_klass, path)
+      response = client.query(query, variables: { externalId: external_id }, context: client_context)
+      check_response_for_errors(response)
+      response_json = response.to_h
+
+      parse_graphql_response(response_json, data_klass, path)
+    rescue StandardError => e
+      handle_errors(e)
+    end
+
+    def mutate(mutation, input, data_klass, path)
+      input.validate!
+      response = client.query(mutation, variables: { input: input.to_graphql_hash }, context: client_context)
+
+      response_json = response.to_h.dig('data', path)
+
+      if response_json
+        result = data_klass.from_graphql_hash(response_json['result']) if response_json['result']
+
+        status = response_json['status']
+        errors = response_json['errors']
+      else
+        status = 'ERROR'
+        errors = response.to_h['errors']
+      end
+
+      PushResult.new(result: result, status: status, errors: errors, input: input)
+    rescue StandardError => e
+      handle_errors(e)
+    end
+
+    # Parse the main part of the graphql response into the appropriate data class.
+    #
+    # @param response_json [GraphQL::Client::Response] the graphql error response
+    # @param data_klass [Class] the class to transform the response into
+    # @param path [String] the path in the response to look for the raw data
+    # @return [Class] an item of the type of `data_klass`
+    def parse_graphql_response(response_json, data_klass, path)
+      data_klass.from_graphql_hash(response_json.dig('data', path))
+    end
+
+    def parse_page_info(response_json, path)
+      Data::PageInfo.from_graphql_hash(response_json.dig('data', path, 'pageInfo'))
+    end
+
+    # Parse the main part of the graphql response into the appropriate data class with additional paging
+    # and connection information.
+    #
+    # @param response_json [GraphQL::Client::Response] the graphql error response
+    # @param data_klass [Class] the class to transform the response into
+    # @param path [String] the path in the response to look for the raw data
+    # @return [Collection<Class>] a wrapped collection with the results
+    def parse_graphql_connection_response(response_json, data_klass, path, item = 'nodes')
+      response_json.dig('data', path, item)&.map do |datum|
+        data_klass.from_graphql_hash(datum.to_h)
+      end
+    end
+
+    # Check that any errors raised have been wrapped in Mirah errors appropriately.
+    def handle_errors(e)
+      case e
+      when Error
+        raise
+      else
+        raise Errors::ClientError, e
+      end
+    end
+
+    def check_response_for_errors(response)
+      if response.errors.any?
+        if response.errors[:data] == ['401 Unauthorized'] # rubocop:disable Style/GuardClause
+          raise Errors::InvalidCredentials, 'The credentials you have supplied are invalid'
+        else
+          raise Errors::ServerError, 'Unknown error from Mirah server: ' + response.errors.values.flatten.join(',')
+        end
+      end
+
+      raise Errors::ServerError, 'Data payload was empty' unless response.data
+    end
+  end
+end