stretchy-model 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a1709205b5fe75817fe79c5047b6f4d3531257cf8a3118f84d8fa4b92adb8932
-  data.tar.gz: 1add1b8c78f9c27362d31e0f1f8c141a429af4b6176b7d521e32e8a3e9230039
+  metadata.gz: d7dff610329ad21128c58429c6f9d08b62138a7fad9adb0f610984bd744db1cf
+  data.tar.gz: 915256c1b413dd34d4777097b878f0c2c7886342b5d8dcfedc2159a405b3bdf2
 SHA512:
-  metadata.gz: cf690ed5affe0224370f50e5208a6fcd0a91e611460fecf3f9a024464b0c87fa9b2718932fefca49c4ad9d587c4cc956b3490738fd794176f35d8f180dc16998
-  data.tar.gz: bc518187e999e3e989332612294ec8152bcc673fd5c025683e1170e8549491d8f8f3b578d4feb82a8fc4b564811f625eaae21fa5b754f0cd8fc7e36ae136c744
+  metadata.gz: 66f98b878a8e78d9d79b53f05edf89a8d4a61d4fd3a5b98d93ef349491c7c87f36d4cadb857b8be5e9e992308609c22d1abc45703eb39b95e78240d87c6ae081
+  data.tar.gz: 0eabc3b84d0aecb0f8051bf53238ec6da5d431c7ff5d0f7c3be20888a20252504e3324c7b558fe455d90c2cf0db827b1d0440e6d03d211569ed8ed7d60dade01

data/README.md

@@ -98,16 +98,6 @@ Model.bulk_in_batches(records, size: 100) do |batch|
 end
 ```
 
-
-## Instrumentation
-```ruby
-Blanket.first
-```
-
-```sh
-Blanket (6.322ms) curl -X GET 'http://localhost:9200/blankets/_search?size=1' -d '{"sort":{"date":"desc"}}'
-```
-
 ## Installation
 
 Install the gem and add to the application's Gemfile by executing:
@@ -118,6 +108,38 @@ If bundler is not being used to manage dependencies, install the gem by executin
 
     $ gem install stretchy-model
 
+<details>
+<summary>Rails Configuration</summary>
+
+
+
+```sh
+rails credentials:edit
+```
+
+#### Add elasticsearch credentials
+```yaml
+elasticsearch:
+   url: localhost:9200
+
+# or opensearch
+# opensearch:
+#    host: https://localhost:9200
+#    user: admin
+#    password: admin
+```
+
+#### Create an initializer 
+<p><sub><em>config/initializers/stretchy.rb</em></sub></p>
+
+```ruby {file=config/initializers/stretchy.rb}
+Stretchy.configure do |config|
+    config.client = Elasticsearch::Client.new url: Rails.application.credentials.elasticsearch.url, log: true
+end
+```
+</details>
+
+
 ## Development
 
 After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
@@ -128,6 +150,25 @@ After checking out the repo, run `bin/setup` to install dependencies. You can al
 > Full documentation on [Elasticsearch Query DSL and Aggregation options](https://github.com/elastic/elasticsearch-rails/tree/main/elasticsearch-persistence)
 
 ## Testing
+<details>
+<summary>Act</summary>
+
+Run github action workflow locally
+
+```sh
+brew install act --HEAD
+```
+
+```sh
+act -P ubuntu-latest=ghcr.io/catthehacker/ubuntu:runner-latest
+```
+
+</details>
+
+<details>
+<summary>Elasticsearch</summary>
+
+
 ```
 docker-compose up elasticsearch
 ```
@@ -136,6 +177,21 @@ docker-compose up elasticsearch
 bundle exec rspec
 ```
 
+</details>
+
+<details>
+<summary>Opensearch</summary>
+
+
+```
+docker-compose up opensearch
+```
+
+```
+ENV['BACKEND']=opensearch bundle rspec 
+```
+</details>
+
 ## Contributing
 
 Bug reports and pull requests are welcome on GitHub at https://github.com/theablefew/stretchy. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [code of conduct](https://github.com/theablefew/stretchy/blob/master/CODE_OF_CONDUCT.md).

data/Rakefile

@@ -2,3 +2,95 @@
 
 require "bundler/gem_tasks"
 task default: %i[]
+
+require 'octokit' 
+require 'versionomy'
+require 'rainbow'
+
+def determine_current_version
+  # Load current version
+  load 'lib/stretchy/version.rb'
+  current_version = Versionomy.parse(Stretchy::VERSION)
+end
+
+def determine_new_version(version)
+  # Load current version
+  current_version = determine_current_version
+
+  # Determine new version
+  case version.to_sym
+  when :major
+    current_version.bump(:major)
+  when :minor
+    current_version.bump(:minor)
+  when :patch
+    current_version.bump(:tiny)
+  else
+    version =~ /\Av?\d+\.\d+\.\d+\z/ ? Versionomy.parse(version).to_s.gsub(/v/,'') : current_version
+  end
+end
+
+def create_release_branch(new_version, base_branch)
+  system("git stash save 'Changes before creating release branch'")
+  system("git fetch origin #{base_branch}")
+  branch_name = "release/v#{new_version}"
+  system("git checkout -b #{branch_name} #{base_branch}")
+  branch_name
+end
+
+def update_version_file(new_version)
+  # Update lib/stretchy/version.rb
+  File.open('lib/stretchy/version.rb', 'w') do |file|
+    file.puts "module Stretchy\n  VERSION = '#{new_version}'\nend"
+  end
+end
+
+def commit_and_push_changes(new_version, branch_name)
+  system("git add lib/stretchy/version.rb")
+  system("git commit -m 'Bump version to v#{new_version}'")
+  system("git tag v#{new_version}")
+  system("git push origin #{branch_name} --tags -f")
+end
+
+def create_pull_request(new_version, base_branch, branch_name)
+  # Create a pull request
+  client = Octokit::Client.new(access_token: ENV['GH_TOKEN'])
+  client.create_pull_request('theablefew/stretchy', base_branch, branch_name, "Release v#{new_version}")
+end
+
+namespace :publish do
+  desc "Create a release"
+  task :release, [:version, :base_branch] do |t, args|
+    args.with_defaults(version: :patch, base_branch: 'main')
+    version = args[:version]
+    base_branch = args[:base_branch]
+  
+    old_version = determine_current_version
+    new_version = determine_new_version(version)
+    puts Rainbow("Bumping version from #{old_version} to #{new_version}").green
+    branch_name = create_release_branch(new_version, base_branch)
+    begin
+    update_version_file(new_version)
+    commit_and_push_changes(new_version, branch_name)
+    create_pull_request(new_version, base_branch, branch_name)
+    rescue => e
+      puts "Error: #{e.message}"
+      puts "Rolling back changes"
+      system("git tag -d v#{new_version}")
+      system("git checkout #{base_branch}")
+      system("git branch -D #{branch_name}")
+    end
+  end
+
+  task :major do
+    Rake::Task['publish:release'].invoke('major')
+  end
+
+  task :minor do
+    Rake::Task['publish:release'].invoke('minor')
+  end
+
+  task :patch do
+    Rake::Task['publish:release'].invoke('patch')
+  end
+end

data/lib/stretchy/attributes/transformers/keyword_transformer.rb

@@ -0,0 +1,85 @@
+module Stretchy
+  module Attributes
+    module Transformers
+      class KeywordTransformer
+
+          KEYWORD_AGGREGATION_KEYS = [:terms, :rare_terms, :significant_terms, :cardinality, :string_stats]
+
+          attr_reader :attribute_types
+
+          def initialize(attribute_types)
+            @attribute_types = attribute_types
+          end
+
+          def cast_value_keys
+            values.transform_values do |value|
+              case value
+              when Array
+                value.map { |item| transform_keys_for_item(item) }
+              when Hash
+                transform_keys_for_item(value)
+              else
+                value
+              end
+            end
+          end
+          
+          def keyword?(arg)
+            attr = @attribute_types[arg.to_s] 
+            return false unless attr
+            attr.is_a?(Stretchy::Attributes::Type::Keyword)
+          end
+
+          def protected?(arg)
+            return false if arg.nil?
+            Stretchy::Relations::AggregationMethods::AGGREGATION_METHODS.include?(arg.to_sym)
+          end
+          
+          def transform(item, *ignore) 
+            item.each_with_object({}) do |(k, v), new_item|
+              if ignore && ignore.include?(k)
+                new_item[k] = v
+                next
+              end
+              new_key = (!protected?(k) && keyword?(k)) ? "#{k}.keyword" : k
+
+              new_value = v
+          
+              if new_value.is_a?(Hash)
+                new_value = transform(new_value)
+              elsif new_value.is_a?(Array)
+                new_value = new_value.map { |i| i.is_a?(Hash) ? transform(i) : i }
+              elsif new_value.is_a?(String) || new_value.is_a?(Symbol) 
+                new_value = "#{new_value}.keyword" if keyword?(new_value)
+              end
+
+              new_item[new_key] = new_value
+            end
+          end
+
+          # If terms are used, we assume that the field is a keyword field
+          # and append .keyword to the field name
+          # {terms: {field: 'gender'}}
+          # or nested aggs
+          # {terms: {field: 'gender'}, aggs: {name: {terms: {field: 'position.name'}}}}
+          # should be converted to
+          # {terms: {field: 'gender.keyword'}, aggs: {name: {terms: {field: 'position.name.keyword'}}}}
+          # {date_histogram: {field: 'created_at', interval: 'day'}}
+          # TODO: There may be cases where we don't want to add .keyword to the field and there should be a way to override this
+          def assume_keyword_field(args={}, parent_match=false)
+            if args.is_a?(Hash)
+              args.each do |k, v|
+                if v.is_a?(Hash) 
+                  assume_keyword_field(v, KEYWORD_AGGREGATION_FIELDS.include?(k))
+                else
+                  next unless v.is_a?(String) || v.is_a?(Symbol)
+                  args[k] = ([:field, :fields].include?(k.to_sym) && v !~ /\.keyword$/ && parent_match) ? "#{v}.keyword" : v.to_s
+                end
+              end
+            end
+          end
+
+      end
+    end
+  end
+end

data/lib/stretchy/attributes/type/keyword.rb

@@ -0,0 +1,11 @@
+module Stretchy
+    module Attributes
+        module Type
+            class Keyword < ActiveModel::Type::String # :nodoc:
+                def type
+                    :keyword
+                end
+            end
+        end
+    end
+end

data/lib/stretchy/attributes.rb

@@ -0,0 +1,10 @@
+module Stretchy
+  module Attributes
+
+    def self.register!
+      ActiveModel::Type.register(:array, ActiveModel::Type::Array)
+      ActiveModel::Type.register(:hash, ActiveModel::Type::Hash)
+      ActiveModel::Type.register(:keyword, Stretchy::Attributes::Type::Keyword)
+    end
+  end
+end

data/lib/stretchy/open_search_compatibility.rb

@@ -0,0 +1,86 @@
+module Stretchy
+    module OpenSearchCompatibility
+    extend ActiveSupport::Concern
+
+        # Patches the Elasticsearch::Persistence::Repository::Search module to remove the 
+        # document type from the request for compatability with OpenSearch
+        def self.opensearch_patch!
+            patch = Module.new do
+                def search(query_or_definition, options={})
+                    request = { index: index_name }
+            
+                    if query_or_definition.respond_to?(:to_hash)
+                        request[:body] = query_or_definition.to_hash
+                    elsif query_or_definition.is_a?(String)
+                        request[:q] = query_or_definition
+                    else
+                        raise ArgumentError, "[!] Pass the search definition as a Hash-like object or pass the query as a String" +
+                            " -- #{query_or_definition.class} given."
+                    end
+            
+                    Elasticsearch::Persistence::Repository::Response::Results.new(self, client.search(request.merge(options)))
+                end
+
+                def count(query_or_definition=nil, options={})
+                    query_or_definition ||= { query: { match_all: {} } }
+                    request = { index: index_name}
+          
+                    if query_or_definition.respond_to?(:to_hash)
+                      request[:body] = query_or_definition.to_hash
+                    elsif query_or_definition.is_a?(String)
+                      request[:q] = query_or_definition
+                    else
+                      raise ArgumentError, "[!] Pass the search definition as a Hash-like object or pass the query as a String" +
+                          " -- #{query_or_definition.class} given."
+                    end
+          
+                    client.count(request.merge(options))['count']
+                end
+            end
+
+            store = Module.new do
+                def save(document, options={})
+                serialized = serialize(document)
+                id = __get_id_from_document(serialized)
+                request = { index: index_name,
+                            id: id,
+                            body: serialized }
+                client.index(request.merge(options))
+              end
+      
+
+              def update(document_or_id, options = {})
+                if document_or_id.is_a?(String) || document_or_id.is_a?(Integer)
+                  id = document_or_id
+                  body = options
+                else
+                  document = serialize(document_or_id)
+                  id = __extract_id_from_document(document)
+                  if options[:script]
+                    body = options
+                  else
+                    body = { doc: document }.merge(options)
+                  end
+                end
+                client.update(index: index_name, id: id, body: body)
+              end
+      
+              def delete(document_or_id, options = {})
+                if document_or_id.is_a?(String) || document_or_id.is_a?(Integer)
+                  id = document_or_id
+                else
+                  serialized = serialize(document_or_id)
+                  id = __get_id_from_document(serialized)
+                end
+                client.delete({ index: index_name, id: id }.merge(options))
+              end
+            end
+
+
+            ::Elasticsearch::Persistence::Repository.send(:include, patch)
+            ::Elasticsearch::Persistence::Repository.send(:include, store)
+        end
+
+
+    end
+end

data/lib/stretchy/querying.rb

@@ -1,11 +1,12 @@
 module Stretchy
   module Querying
     delegate :first, :first!, :last, :last!, :exists?, :has_field, :any?, :many?, to: :all
-    delegate :order, :limit, :size, :sort, :where, :rewhere, :eager_load, :includes,  :create_with, :none, :unscope, to: :all
-    delegate :or_filter, :filter, :fields, :source, :highlight, :aggregation, to: :all
-    delegate :skip_callbacks, :routing, to: :all
-    delegate :search_options, :routing, to: :all
-    delegate :must, :must_not, :should, :where_not, :query_string, to: :all
+    delegate :order, :limit, :size, :sort, :rewhere, :eager_load, :includes,  :create_with, :none, :unscope, to: :all
+    delegate :or_filter, :fields, :source, :highlight, to: :all
+    delegate *Stretchy::Relations::AggregationMethods::AGGREGATION_METHODS, to: :all
+
+    delegate :skip_callbacks, :routing, :search_options, to: :all
+    delegate :must, :must_not, :should, :where_not, :where, :filter_query, :query_string, to: :all
 
     def fetch_results(es)
       unless es.count?

data/lib/stretchy/relation.rb

@@ -4,7 +4,7 @@ module Stretchy
     class Relation
 
         # These methods can accept multiple values.
-        MULTI_VALUE_METHODS  = [:order, :where, :or_filter, :filter, :bind, :extending, :unscope, :skip_callbacks]
+        MULTI_VALUE_METHODS  = [:order, :where, :or_filter, :filter_query, :bind, :extending, :unscope, :skip_callbacks]
 
         # These methods can accept a single value.
         SINGLE_VALUE_METHODS = [:limit, :offset, :routing, :size]
@@ -16,7 +16,7 @@ module Stretchy
         VALUE_METHODS = MULTI_VALUE_METHODS + SINGLE_VALUE_METHODS
 
         # Include modules.
-        include Relations::FinderMethods, Relations::SpawnMethods, Relations::QueryMethods, Relations::SearchOptionMethods, Delegation
+        include Relations::FinderMethods, Relations::SpawnMethods, Relations::QueryMethods, Relations::AggregationMethods, Relations::SearchOptionMethods, Delegation
 
         # Getters.
         attr_reader :klass, :loaded
@@ -162,7 +162,7 @@ module Stretchy
         #
         # @return [QueryBuilder] The query builder for the relation.
         def query_builder
-          Relations::QueryBuilder.new(values)
+          Relations::QueryBuilder.new(values, klass.attribute_types)
         end
 
     end