rom-elasticsearch 0.1.0

data/lib/rom/elasticsearch/errors.rb

@@ -0,0 +1,23 @@
+module ROM
+  module Elasticsearch
+    # @api private
+    class Error < StandardError
+      def initialize(wrapped_error)
+        super(wrapped_error.message)
+        @wrapped_error = wrapped_error
+      end
+
+      attr_reader :wrapped_error
+    end
+
+    # @api private
+    class SearchError < Error
+      attr_reader :query
+
+      def initialize(wrapped_error, query)
+        super(wrapped_error)
+        @query = query
+      end
+    end
+  end
+end

data/lib/rom/elasticsearch/gateway.rb

@@ -0,0 +1,81 @@
+require 'elasticsearch'
+require 'uri'
+
+require 'rom/gateway'
+require 'rom/support/inflector'
+require 'rom/elasticsearch/dataset'
+
+module ROM
+  module Elasticsearch
+    # Elasticsearch gateway
+    #
+    # @example basic configuration
+    #   conf = ROM::Configuration.new(:elasticsearch, 'http://localhost:9200')
+    #
+    #   class Posts < ROM::Relation[:elasticsearch]
+    #     schema(:posts) do
+    #       attribute :id, Types::Int
+    #       attribute :title, Types::String
+    #
+    #       primary_key :id
+    #     end
+    #
+    #     def like(title)
+    #       query(prefix: { title: title })
+    #     end
+    #   end
+    #
+    #   conf.register_relation(Posts)
+    #
+    #   rom = ROM.container(conf)
+    #
+    #   posts = rom.relations[:posts]
+    #
+    #   posts.command(:create).call(id: 1, title: 'Hello World')
+    #
+    #   posts.like('Hello').first
+    #
+    # @api public
+    class Gateway < ROM::Gateway
+      adapter :elasticsearch
+
+      # @!attribute [r] url
+      #   @return [URI] Connection URL
+      attr_reader :url
+
+      # @!attribute [r] client
+      #   @return [::Elasticsearch::Client] configured ES client
+      attr_reader :client
+
+      # @api private
+      def initialize(uri, log: false)
+        @url = URI.parse(uri)
+        @client = ::Elasticsearch::Client.new(host: url.select(:host, :port).join(":"), log: log)
+      end
+
+      # Return true if a dataset with the given :index exists
+      #
+      # @param [Symbol] index The name of the index
+      #
+      # @return [Boolean]
+      #
+      # @api public
+      def dataset?(index)
+        client.indices.exists?(index: index)
+      end
+      alias_method :index?, :dataset?
+
+      # Get a dataset by its :index name
+      #
+      # @param [Symbol] index The name of the index
+      #
+      # @return [Dataset]
+      #
+      # @api public
+      def dataset(index)
+        Dataset.new(client, params: { index: index, type: Inflector.singularize(index).to_sym })
+      end
+      alias_method :[], :dataset
+    end
+  end
+end

data/lib/rom/elasticsearch/plugins/relation/query_dsl.rb

@@ -0,0 +1,57 @@
+require 'rom/global'
+require 'elasticsearch/dsl'
+
+module ROM
+  module Elasticsearch
+    module Plugins
+      module Relation
+        # Relation plugin which adds query DSL from elasticsearch-dsl gem
+        #
+        # @api public
+        module QueryDSL
+          # @api private
+          def self.included(klass)
+            super
+            klass.include(InstanceMethods)
+            klass.option :query_builder, default: -> { Builder.new(self) }
+          end
+
+          # @api public
+          module InstanceMethods
+            # Restrict a relation via query DSL
+            #
+            # @see Relation#search
+            # @see https://github.com/elastic/elasticsearch-ruby/tree/master/elasticsearch-dsl
+            #
+            # @return [Relation]
+            #
+            # @api public
+            def search(options = EMPTY_HASH, &block)
+              if block
+                super(query_builder.search(&block).to_hash)
+              else
+                super
+              end
+            end
+          end
+
+          class Builder
+            include ::Elasticsearch::DSL
+
+            attr_reader :relation
+
+            def initialize(relation)
+              @relation = relation
+            end
+          end
+        end
+      end
+    end
+  end
+
+  plugins do
+    adapter :elasticsearch do
+      register :query_dsl, ROM::Elasticsearch::Plugins::Relation::QueryDSL, type: :relation
+    end
+  end
+end

data/lib/rom/elasticsearch/query_methods.rb

@@ -0,0 +1,64 @@
+require 'rom/elasticsearch/errors'
+
+module ROM
+  module Elasticsearch
+    # Dataset's query methods
+    #
+    # @see Dataset
+    #
+    # @api public
+    module QueryMethods
+      # Return a new dataset configured to search by :id
+      #
+      # @param [Integer] id
+      #
+      # @return [Dataset]
+      #
+      # @see Relation#get
+      #
+      # @api public
+      def get(id)
+        params(id: id)
+      end
+
+      # Return a new dataset configured to search via new body options
+      #
+      # @param [Hash] options Body options
+      #
+      # @return [Dataset]
+      #
+      # @see Relation#search
+      #
+      # @api public
+      def search(options)
+        body(options)
+      end
+
+      # Return a new dataset configured to search via :query_string body option
+      #
+      # @param [String] expression A string query
+      #
+      # @return [Dataset]
+      #
+      # @see Relation#query_string
+      #
+      # @api public
+      def query_string(expression)
+        query(query_string: { query: expression })
+      end
+
+      # Return a new dataset configured to search via :query body option
+      #
+      # @param [Hash] query A query hash
+      #
+      # @return [Dataset]
+      #
+      # @see Relation#query
+      #
+      # @api public
+      def query(query)
+        body(query: query)
+      end
+    end
+  end
+end

data/lib/rom/elasticsearch/relation.rb

@@ -0,0 +1,241 @@
+require 'rom/relation'
+require 'rom/elasticsearch/types'
+require 'rom/elasticsearch/schema'
+require 'rom/elasticsearch/attribute'
+
+module ROM
+  module Elasticsearch
+    # Elasticsearch relation API
+    #
+    # Provides access to indexed data, and methods for managing indices.
+    # Works like a standard Relation, which means it's lazy and composable,
+    # and has access to commands via `Relation#command`.
+    #
+    # Indices are configured based on two settings:
+    # - `Relation#name.dataset` - which is configured in a standard way via `schema` block
+    # - `Relation.index_settings` - which is a class-level setting
+    #
+    # Optionally, query DSL can be enabled via `:query_dsl` plugin.
+    #
+    # @example setting up a relation
+    #   class Pages < ROM::Relation[:elasticsearch]
+    #     schema do
+    #       attribute :id, Types::ID
+    #       attribute :title, Types.Keyword
+    #       attribute :body, Types.Text(analyzer: "snowball")
+    #     end
+    #   end
+    #
+    # @example using query DSL
+    #   class Users < ROM::Relation[:elasticsearch]
+    #     use :query_dsl
+    #
+    #     schema do
+    #       # ...
+    #     end
+    #   end
+    #
+    #   users.search do
+    #     query do
+    #       match name: "Jane"
+    #     end
+    #   end
+    #
+    # @api public
+    class Relation < ROM::Relation
+      include ROM::Elasticsearch
+
+      adapter :elasticsearch
+
+      # @!method self.index_settings
+      #   Manage the index_settings
+      #
+      #   This is set by default to:
+      #
+      #   ``` ruby
+      #   { number_of_shards: 1,
+      #     index: {
+      #       analysis: {
+      #         analyzer: {
+      #           standard_stopwords: {
+      #             type: "standard",
+      #             stopwords: "_english_"
+      #           }
+      #         }
+      #       }
+      #   } }.freeze
+      #   ```
+      #
+      #   @overload index_settings
+      #     Return the index_settings that the relation will use
+      #     @return [Hash]
+      #
+      #   @overload index_settings(settings)
+      #     Set index settings
+      #
+      #     @see https://www.elastic.co/guide/en/elasticsearch/guide/current/index-management.html
+      #
+      #     @example
+      #       class Users < ROM::Relation[:elasticsearch]
+      #         index_settings(
+      #           # your custom settings
+      #         )
+      #
+      #         schema do
+      #           # ...
+      #         end
+      #       end
+      #
+      #     @param [Hash] index_settings_hash
+      defines :index_settings
+
+      schema_class Elasticsearch::Schema
+      schema_attr_class Elasticsearch::Attribute
+
+      # Overridden output_schema, as we *always* want to use it,
+      # whereas in core, it is only used when there's at least one read-type
+      option :output_schema, default: -> { schema.to_output_hash }
+
+      # Default index settings that can be overridden
+      index_settings(
+        { number_of_shards: 1,
+          index: {
+            analysis: {
+              analyzer: {
+                standard_stopwords: {
+                  type: "standard",
+                  stopwords: "_english_"
+                }
+              }
+            }
+          } }.freeze
+      )
+
+      # Map indexed data
+      #
+      # @yieldparam [Hash,ROM::Struct]
+      #
+      # @return [Array<Hash,ROM::Struct>]
+      #
+      # @api public
+      def map(&block)
+        to_a.map(&block)
+      end
+
+      # Pluck specific attribute values
+      #
+      # @param [Symbol] name The name of the attribute
+      #
+      # @return [Array]
+      #
+      # @api public
+      def pluck(name)
+        map { |t| t[name] }
+      end
+
+      # Restrict indexed data by id
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def get(id)
+        new(dataset.get(id))
+      end
+
+      # Restrict relation data by a search query
+      #
+      # @example
+      #   users.search(query: { match: { name: "Jane" } })
+      #
+      # @param [Hash] options Search options compatible with Elasticsearch::Client API
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def search(options)
+        new(dataset.search(options))
+      end
+
+      # Restrict relation data by a query search
+      #
+      # @example
+      #   users.query(match: { name: "Jane" })
+      #
+      # @param [Hash] query Query options compatible with Elasticsearch::Client API
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def query(query)
+        new(dataset.query(query))
+      end
+
+      # Restrict relation data by a string-based query
+      #
+      # @example
+      #   users.query_string("name:'Jane'")
+      #
+      # @param [Hash] query Query string compatible with Elasticsearch::Client API
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def query_string(expr)
+        new(dataset.query_string(expr))
+      end
+
+      # Create relation's index in ES
+      #
+      # @return [Hash] raw response from the client
+      #
+      # @api public
+      def create_index
+        dataset.create_index(index_params)
+      end
+
+      # Delete relation's index in ES
+      #
+      # @return [Hash] raw response from the client
+      #
+      # @api public
+      def delete_index
+        dataset.delete_index
+      end
+
+      # Delete all indexed data from the current relation
+      #
+      # @return [Hash] raw response from the client
+      #
+      # @api public
+      def delete
+        dataset.delete
+      end
+
+      # Refresh indexed data
+      #
+      # @example
+      #   users.command(:create).call(id: 1, name: "Jane").refresh.to_a
+      #
+      # @return [Relation]
+      #
+      # @api public
+      def refresh
+        new(dataset.refresh)
+      end
+
+      private
+
+      # Dataset index params based on relation configuration
+      #
+      # @return [Hash]
+      #
+      # @api private
+      def index_params
+        { index: name.dataset,
+          body: {
+            settings: self.class.index_settings,
+            mappings: { dataset.type => { properties: schema.to_properties } } } }
+      end
+    end
+  end
+end