Remove type from persistent requests

mauricebolhuis · mauricebolhuis · commit 5bbe5aaa385c · 2022-09-22T07:56:32.000+02:00
diff --git a/opensearch-persistence/lib/opensearch/persistence/repository/find.rb b/opensearch-persistence/lib/opensearch/persistence/repository/find.rb
@@ -64,7 +64,6 @@ def find(*args)
         #
         def exists?(id, options={})
           request = { index: index_name, id: id }
-          request[:type] = document_type if document_type
           client.exists(request.merge(options))
         end
 
@@ -84,7 +83,6 @@ def exists?(id, options={})
         #
         def __find_one(id, options={})
           request = { index: index_name, id: id }
-          request[:type] = document_type if document_type
           document = client.get(request.merge(options))
           deserialize(document)
         rescue OpenSearch::Transport::Transport::Errors::NotFound => e
@@ -95,7 +93,6 @@ def __find_one(id, options={})
         #
         def __find_many(ids, options={})
           request = { index: index_name, body: { ids: ids } }
-          request[:type] = document_type if document_type
           documents = client.mget(request.merge(options))
           documents[DOCS].map do |document|
             deserialize(document) if document[FOUND]
diff --git a/opensearch-persistence/lib/opensearch/persistence/repository/search.rb b/opensearch-persistence/lib/opensearch/persistence/repository/search.rb
@@ -60,8 +60,7 @@ module Search
         # @return [OpenSearch::Persistence::Repository::Response::Results]
         #
         def search(query_or_definition, options={})
-          request = { index: index_name,
-                      type: document_type }
+          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)
@@ -98,8 +97,7 @@ def search(query_or_definition, options={})
         #
         def count(query_or_definition=nil, options={})
           query_or_definition ||= { query: { match_all: {} } }
-          request = { index: index_name,
-                      type: document_type }
+          request = { index: index_name }
 
           if query_or_definition.respond_to?(:to_hash)
             request[:body] = query_or_definition.to_hash
diff --git a/opensearch-persistence/lib/opensearch/persistence/repository/store.rb b/opensearch-persistence/lib/opensearch/persistence/repository/store.rb
@@ -40,7 +40,6 @@ def save(document, options={})
           request = { index: index_name,
                       id: id,
                       body: serialized }
-          request[:type] = document_type if document_type
           client.index(request.merge(options))
         end
 
@@ -65,7 +64,6 @@ 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
-            type = document_type
           else
             document = serialize(document_or_id)
             id = __extract_id_from_document(document)
@@ -74,9 +72,8 @@ def update(document_or_id, options = {})
             else
               body = { doc: document }.merge(options)
             end
-            type = document.delete(:type) || document_type
           end
-          client.update(index: index_name, id: id, type: type, body: body)
+          client.update(index: index_name, id: id, body: body)
         end
 
         # Remove the serialized object or document with specified ID from OpenSearch
@@ -98,7 +95,7 @@ def delete(document_or_id, options = {})
             serialized = serialize(document_or_id)
             id = __get_id_from_document(serialized)
           end
-          client.delete({ index: index_name, type: document_type, id: id }.merge(options))
+          client.delete({ index: index_name, id: id }.merge(options))
         end
       end
     end
diff --git a/opensearch-persistence/spec/repository/find_spec.rb b/opensearch-persistence/spec/repository/find_spec.rb
@@ -46,17 +46,6 @@
         expect(repository.exists?('1')).to be(false)
       end
     end
-
-    context 'when options are provided' do
-
-      let(:id) do
-        repository.save(a: 1)['_id']
-      end
-
-      it 'applies the options' do
-        expect(repository.exists?(id, type: 'other_type')).to be(false)
-      end
-    end
   end
 
   describe '#find' do
@@ -132,48 +121,6 @@
       end
     end
 
-    context 'when options are provided' do
-
-      context 'when a single id is passed' do
-
-        let!(:id) do
-          repository.save(a: 1)['_id']
-        end
-
-        it 'applies the options' do
-          expect {
-            repository.find(id, type: 'none')
-          }.to raise_exception(OpenSearch::Persistence::Repository::DocumentNotFound)
-        end
-      end
-
-      context 'when an array of ids is passed' do
-
-        let!(:ids) do
-          3.times.collect do |i|
-            repository.save(a: i)['_id']
-          end
-        end
-
-        it 'applies the options' do
-          expect(repository.find(ids, type: 'none')).to eq([nil, nil, nil])
-        end
-      end
-
-      context 'when multiple ids are passed' do
-
-        let!(:ids) do
-          3.times.collect do |i|
-            repository.save(a: i)['_id']
-          end
-        end
-
-        it 'applies the options' do
-          expect(repository.find(*ids, type: 'none')).to eq([nil, nil, nil])
-        end
-      end
-    end
-
     context 'when a document_type is defined on the class' do
 
       let(:repository) do
diff --git a/opensearch-persistence/spec/repository/search_spec.rb b/opensearch-persistence/spec/repository/search_spec.rb
@@ -29,169 +29,55 @@
       DEFAULT_REPOSITORY
     end
 
-    context 'when the repository does not have a type set' do
-
       before do
         repository.save({ name: 'user' }, refresh: true)
       end
 
-      context 'when a query definition is provided as a hash' do
-
-        it 'uses the default document type' do
-          expect(repository.search({ query: { match: { name: 'user' } } }).first).to eq('name' => 'user')
-        end
-      end
-
-      context 'when a query definition is provided as a string' do
-
-        it 'uses the default document type' do
-          expect(repository.search('user').first).to eq('name' => 'user')
-        end
-      end
-
-      context 'when the query definition is neither a String nor a Hash' do
+    context 'when a query definition is provided as a hash' do
 
-        it 'raises an ArgumentError' do
-          expect {
-            repository.search(1)
-          }.to raise_exception(ArgumentError)
-        end
-      end
-
-      context 'when options are provided' do
-
-        context 'when a query definition is provided as a hash' do
-
-          it 'uses the default document type' do
-            expect(repository.search({ query: { match: { name: 'user' } } }, type: 'other').first).to be_nil
-          end
-        end
-
-        context 'when a query definition is provided as a string' do
-
-          it 'uses the default document type' do
-            expect(repository.search('user', type: 'other').first).to be_nil
-          end
-        end
-
-        context 'when the query definition is neither a String nor a Hash' do
-
-          it 'raises an ArgumentError' do
-            expect {
-              repository.search(1)
-            }.to raise_exception(ArgumentError)
-          end
-        end
+      it 'uses the default document type' do
+        expect(repository.search({ query: { match: { name: 'user' } } }).first).to eq('name' => 'user')
       end
     end
 
-    context 'when the repository does have a type set' do
+    context 'when a query definition is provided as a string' do
 
-      let(:repository) do
-        MyTestRepository.new(document_type: 'other_note')
+      it 'uses the default document type' do
+        expect(repository.search('user').first).to eq('name' => 'user')
       end
+    end
 
-      before do
-        repository.save({ name: 'user' }, refresh: true)
-      end
-
-      context 'when options are provided' do
-
-        context 'when a query definition is provided as a hash' do
-
-          it 'uses the options' do
-            expect(repository.search({ query: { match: { name: 'user' } } }, type: 'other').first).to be_nil
-          end
-        end
-
-        context 'when a query definition is provided as a string' do
-
-          it 'uses the options' do
-            expect(repository.search('user', type: 'other').first).to be_nil
-          end
-        end
-
-        context 'when the query definition is neither a String nor a Hash' do
+    context 'when the query definition is neither a String nor a Hash' do
 
-          it 'raises an ArgumentError' do
-            expect {
-              repository.search(1)
-            }.to raise_exception(ArgumentError)
-          end
-        end
+      it 'raises an ArgumentError' do
+        expect {
+          repository.search(1)
+        }.to raise_exception(ArgumentError)
       end
     end
   end
 
   describe '#count' do
 
-    context 'when the repository does not have a type set' do
-
-      let(:repository) do
-        DEFAULT_REPOSITORY
-      end
-
-      before do
-        repository.save({ name: 'user' }, refresh: true)
-      end
-
-      context 'when a query definition is provided as a hash' do
-
-        it 'uses the default document type' do
-          expect(repository.count({ query: { match: { name: 'user' } } })).to eq(1)
-        end
-      end
-
-      context 'when a query definition is provided as a string' do
-
-        it 'uses the default document type' do
-          expect(repository.count('user')).to eq(1)
-        end
-      end
-
-      context 'when options are provided' do
-
-        context 'when a query definition is provided as a hash' do
-
-          it 'uses the options' do
-            expect(repository.count({ query: { match: { name: 'user' } } }, type: 'other')).to eq(0)
-          end
-        end
-
-        context 'when a query definition is provided as a string' do
+    let(:repository) do
+      DEFAULT_REPOSITORY
+    end
 
-          it 'uses the options' do
-            expect(repository.count('user', type: 'other')).to eq(0)
-          end
-        end
-      end
+    before do
+      repository.save({ name: 'user' }, refresh: true)
     end
 
-    context 'when the repository does have a type set' do
+    context 'when a query definition is provided as a hash' do
 
-      let(:repository) do
-        MyTestRepository.new(document_type: 'other_note')
+      it 'uses the default document type' do
+        expect(repository.count({ query: { match: { name: 'user' } } })).to eq(1)
       end
+    end
 
-      before do
-        repository.save({ name: 'user' }, refresh: true)
-      end
-
-      context 'when options are provided' do
-
-        context 'when a query definition is provided as a hash' do
-
-          it 'uses the options' do
-            expect(repository.count({ query: { match: { name: 'user' } } }, type: 'other')).to eq(0)
-          end
-        end
-
-        context 'when a query definition is provided as a string' do
+    context 'when a query definition is provided as a string' do
 
-          it 'uses the options' do
-            expect(repository.count('user', type: 'other')).to eq(0)
-          end
-        end
+      it 'uses the default document type' do
+        expect(repository.count('user')).to eq(1)
       end
     end
   end
diff --git a/opensearch-persistence/spec/repository/store_spec.rb b/opensearch-persistence/spec/repository/store_spec.rb
@@ -74,14 +74,12 @@ def serialize(document)
     context 'when options are provided' do
 
       let!(:response) do
-        repository.save(document, type: 'other_note')
+        repository.save(document)
       end
 
       it 'saves the document using the options' do
-        expect {
-          repository.find(response['_id'])
-        }.to raise_exception(OpenSearch::Persistence::Repository::DocumentNotFound)
-        expect(repository.find(response['_id'], type: 'other_note')).to eq('a' => 1)
+        repository.find(response['_id'])
+        expect(repository.find(response['_id'])).to eq('a' => 1)
       end
     end
   end
@@ -331,7 +329,7 @@ def to_hash
     context 'when the document does not exist' do
 
       before do
-        repository.create_index!(include_type_name: true)
+        repository.create_index!
       end
 
       it 'raises an exception' do
diff --git a/opensearch-persistence/spec/repository_spec.rb b/opensearch-persistence/spec/repository_spec.rb
