gladwords 1.0.1

data/lib/gladwords/commands/create.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+require 'gladwords/commands/core'
+
+module Gladwords
+  module Commands
+    # Create command
+    # This command uses the ADD operator to create entities in AdWords
+    # @api public
+    class Create < ROM::Commands::Create
+      include Core
+
+      adapter :adwords
+
+      adwords_operator :ADD
+    end
+  end
+end

data/lib/gladwords/commands/delete.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+require 'gladwords/commands/core'
+
+module Gladwords
+  module Commands
+    # Delete command
+    # This command uses the REMOVE operator to delete entities in AdWords
+    # @api public
+    class Delete < ROM::Commands::Delete
+      include Core
+
+      adapter :adwords
+      adwords_operator :REMOVE
+      operand_mapper ->(entity) { { id: entity[:id] } }
+
+      def execute
+        perform_operations(relation.to_a)
+      end
+    end
+  end
+end

data/lib/gladwords/commands/error_wrapper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Gladwords
+  module Commands
+    # Shared error handler for all AdWords commands
+    #
+    # @api private
+    module ErrorWrapper
+      # Handle AdWords errors and re-raise ROM-specific errors
+      #
+      # @return [Hash, Array<Hash>]
+      #
+      # @raise AdWords::Error
+      #
+      # @api public
+      def call(*args)
+        super
+      rescue *ERROR_MAP.keys => e
+        raise ERROR_MAP.fetch(e.class, Error), e
+      end
+
+      alias [] call
+    end
+  end
+end

data/lib/gladwords/commands/update.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require 'gladwords/commands/core'
+
+module Gladwords
+  module Commands
+    # Update command
+    # This command uses the SET operator to update entities in AdWords
+    # @api public
+    class Update < ROM::Commands::Update
+      include Core
+
+      adapter :adwords
+      adwords_operator :SET
+    end
+  end
+end

data/lib/gladwords/errors.rb

@@ -0,0 +1,7 @@
+# frozen_string_literal: true
+
+module Gladwords
+  MissingPrimaryKeyError = Class.new(StandardError)
+
+  ERROR_MAP = {}.freeze
+end

data/lib/gladwords/gateway.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'rom/gateway'
+
+module Gladwords
+  # AdWords gateway
+  #
+  # @api public
+  class Gateway < ROM::Gateway
+    class DatasetMappingError < StandardError; end
+    include Inflection
+
+    attr_reader :datasets, :client
+
+    defines :datasets_mapping
+
+    datasets_mapping(
+      ad_group_criteria: :AdGroupCriterionService
+    )
+
+    def initialize(config)
+      @client = config.fetch(:client)
+    end
+
+    def dataset(name)
+      service_name = self.class.datasets_mapping.fetch(name) do
+        inflector.camelize(inflector.singularize(name)) + 'Service'
+      end
+
+      client.service(service_name.to_sym, :v201809)
+    rescue StandardError => e
+      raise DatasetMappingError,
+            "Could not map #{name} to an Adwords service. \n" \
+            'Please register it by adding it to the ' \
+            "Gladwords::Gateway.dataset_mappings config (Original: #{e.message}). \n" \
+            '  i.e. Gladwords::Gateway.dataset_mappings[:customers] = :CustomerService'
+    end
+
+    def dataset?(name)
+      self.class.datasets_mapping.key?(name.to_sym)
+    end
+
+    def service_registry(name)
+      srv = dataset(name.to_sym)
+      srv.send(:get_service_registry)
+    end
+  end
+end

data/lib/gladwords/inflector.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+require 'dry/inflector'
+
+module Gladwords
+  Inflector = Dry::Inflector.new do |i|
+    # This is part of ROM::Inflector's configuration
+    i.plural(/people\z/i, 'people')
+
+    i.plural(/criterion\z/i, 'criteria')
+    i.singular(/criteria\z/i, 'criterion')
+  end
+
+  # Inflection mixin
+  module Inflection
+    def inflector
+      Gladwords::Inflector
+    end
+  end
+end

data/lib/gladwords/relation.rb

@@ -0,0 +1,197 @@
+# frozen_string_literal: true
+
+require 'rom/relation'
+require 'gladwords/schema'
+require 'gladwords/schema/inferrer'
+require 'gladwords/schema/dsl'
+require 'gladwords/relation/association_methods'
+
+module Gladwords
+  # AdWords API relation
+  #
+  # @api public
+  class Relation < ROM::Relation
+    include Gladwords
+    include AssociationMethods
+
+    class FieldResolutionError < StandardError; end
+    class InvalidRequestMethodError < StandardError; end
+
+    adapter :adwords
+
+    defines :action
+    action :get
+
+    defines :default_select_fields
+    default_select_fields -> { default_fields }
+
+    option :method, default: -> { self.class.action }
+    option :selector, default: -> { {} }
+    option :primary_key, default: -> { schema.primary_key_name }
+
+    schema_class Gladwords::Schema
+    schema_dsl Gladwords::Schema::DSL
+    schema_inferrer Gladwords::Schema::Inferrer.new.freeze
+
+    struct_namespace Gladwords::Struct
+
+    def primary_key
+      schema.canonical.primary_key
+    end
+
+    def by_pk(pkey)
+      if primary_key.empty?
+        raise MissingPrimaryKeyError, "Missing primary key for :\#{schema.name}"
+      end
+
+      # This is most likely wrong in edge cases.
+      # https://github.com/rom-rb/rom-sql/blob/dea2fb877a6f5e8a60df3f0eb0b54c499443b0b2/lib/rom/sql/relation.rb#L63
+      where(schema.canonical.primary_key.first.name => pkey).limit(1)
+    end
+
+    def each
+      return to_enum unless block_given?
+
+      materialized = view
+
+      entries = materialized.is_a?(Array) ? materialized : materialized.fetch(:entries, [])
+
+      if auto_map?
+        schema_mapped = entries.map { |tuple| output_schema[tuple] }
+        mapped = mapper.call(schema_mapped)
+        mapped.each { |struct| yield(struct) }
+      else
+        entries.each { |tuple| yield(output_schema[tuple]) }
+      end
+    end
+
+    # Pluck fields from a relation
+    #
+    # @example
+    #   users.pluck(:id).to_a
+    #   # [1, 2, 3]
+    #
+    # @param [Symbol] key An optional name of the key for extracting values
+    #                     from tuples
+    #
+    # @api public
+    def pluck(name)
+      select(name) >> ->(ents) { ents.map(&name) }
+    end
+
+    # Specify a method to use when accessing the SOAP interface
+    #
+    # @example
+    #   customers.request(:get_customers).to_a
+    #
+    # @param [Symbol] method_name Method name on SOAP interface
+    #
+    # @api public
+    def request(method_name)
+      unless dataset.send(:get_service_registry).get_method_signature(method_name)
+        raise InvalidRequestMethodError, "Dataset does not respond to ##{method_name}"
+      end
+
+      with(method: method_name)
+    end
+
+    def select(*fields)
+      mapped_fields = fields.map(&:to_s).map { |t| camelcase(t) }
+      old_fields = options.dig(:selector, :fields) || []
+      new_fields = Set[*old_fields, *mapped_fields].to_a
+      selected = with_selector(options[:selector].merge(fields: new_fields))
+      selected.with(schema: schema.project(*fields))
+    end
+
+    def where(**attrs)
+      with_selector(options[:selector].deep_merge(predicates: where_predicates(attrs)))
+    end
+
+    def where_predicates(**attrs)
+      old_predicates = options.dig(:selector, :predicates) || EMPTY_SET
+
+      new_predicates = attrs.map do |name, value|
+        { field: camelcase(name),
+          operator: 'IN',
+          values: [value].flatten }
+      end
+
+      Set[*old_predicates, *new_predicates].to_a
+    end
+
+    def total_count
+      view[:total_num_entries]
+    end
+
+    def count
+      limit(0).send(:view)[:total_num_entries]
+    end
+
+    def offset(amt)
+      paging = { paging: { start_index: amt } }
+      with_selector(paging)
+    end
+
+    def limit(amt)
+      paging = { paging: { number_results: amt } }
+      with_selector(paging)
+    end
+
+    private
+
+    def with_selector(**attrs)
+      with(selector: options[:selector].deep_merge(attrs))
+    end
+
+    def view
+      return @view if @view
+
+      resolve_dependant_associations
+
+      @view ||= dataset.public_send(options.fetch(:method, self.class.action), compiled_selector)
+    end
+
+    def resolve_dependant_associations
+      deps = options[:dependant_associations]
+      depedendant_predicates = deps.map do |fk, relation|
+        [fk, relation.pluck(:id).call]
+      end
+
+      new_predicates = where_predicates(Hash[depedendant_predicates])
+      options[:selector][:predicates] = new_predicates
+    end
+
+    def camelcase(str)
+      inflector = Gladwords::Inflector
+      inflector.camelize(str)
+    end
+
+    def default_fields
+      fetch_db_fields.map { |entry| camelcase(entry[:field]) }.uniq
+    end
+    memoize :default_fields
+
+    def compiled_selector
+      fields = if selector.fetch(:fields, []).empty?
+                 instance_exec(&self.class.default_select_fields)
+               else
+                 selector[:fields]
+               end
+      { fields: fields, **options[:selector] }
+    end
+
+    def fetch_db_fields
+      version = options.fetch(:dataset).version.to_sym
+      db = Gladwords.selector_fields_db(version)
+      db_fields = db.dig(name.to_sym, options[:method].to_sym)
+
+      return db_fields unless db_fields.nil?
+
+      raise FieldResolutionError,
+            "Could not mind fields for: #{name} -> #{options[:method]}.\n" \
+            'Please ensure that relation name and method are correct by ' \
+            'inspecting `Gladwords.selector_fields_db(:#{version})` and ensure ' \
+            'the relation name and method exist.'
+    end
+  end
+end

data/lib/gladwords/relation/association_methods.rb

@@ -0,0 +1,29 @@
+# frozen_string_literal: true
+
+require 'gladwords/relation/joined_relation'
+
+module Gladwords
+  class Relation < ROM::Relation
+    # Instance methods for associations
+    #
+    # @api public
+    module AssociationMethods
+      def self.included(klass)
+        klass.option :dependant_associations, default: -> { [] }
+      end
+
+      # Join with other datasets
+      #
+      # @param [Array<Dataset>] args A list of dataset to join with
+      #
+      # @return [Dataset]
+      #
+      # @api public
+      def join(*args)
+        targets = nodes(*args)
+
+        JoinedRelation.new(self, targets).relation
+      end
+    end
+  end
+end

data/lib/gladwords/relation/joined_relation.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'rom/array_dataset'
+
+module Gladwords
+  class Relation < ROM::Relation
+    # Helper for bulding out a join relationship
+    #
+    # @api private
+    class JoinedRelation
+      extend Dry::Initializer
+
+      param :source
+      param :targets
+
+      option :base_class, default: -> { ROM::Relation::Combined }
+
+      def relation
+        comb = base_class.new(source, targets)
+        targets.each { |rel| build_accessor(rel, comb) }
+        comb
+      end
+
+      private
+
+      # Will set methods on a relation such as `#ad_groups` such that when
+      # they are accessed, a new relation is returned with the proper
+      # scoping. By default, the relation will include *all* children, this
+      # ensures that only the children which are related by a foreign key
+      # (i.e. `campaign_id`) are returned.
+      def build_accessor(rel, comb)
+        fk = rel.meta[:keys].fetch(:id)
+        node = build_pristine_relation(
+          rel.relation,
+          dependant_associations: [[fk, source]],
+          auto_struct: true,
+          auto_map: true
+        )
+        comb.define_singleton_method(node.name.to_sym) { node }
+      end
+
+      def build_pristine_relation(relation, **params)
+        opts = relation.options.dup
+        opts.delete(:mappers)
+        opts.delete(:__registry__)
+        opts.delete(:meta)
+
+        relation.class.new(relation.dataset, **opts, **params)
+      end
+    end
+  end
+end