solis 0.115.0 → 0.116.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c9039f8bba386333b11237b9914c7fdeee57ad8094ea57058815f2fc008d4a7
-  data.tar.gz: ea7269d0380b39c1a88a7d064c503c972194a548441c6c32459ab4ca7187cab8
+  metadata.gz: affbb3891268851909a6a35684c11a36f6e67d617dea1e977015124ca0bd8118
+  data.tar.gz: 920ad82dc52d0bdefe3bd1e08b631e6907d6f13952f5573fc3bb8f392b03521d
 SHA512:
-  metadata.gz: 17d2aa3f39b2bee0cb267996467ba8a0fe08d433e3e63c9dbab3df8624cac6ebf45703bc90c606f3c7d90d4c0ab12b72c3794056c11481f008141c456fe27675
-  data.tar.gz: 0e9faa327c21a51aa3413ed0d90c20f781186c360ae4e33c3d2b6432c1e9779e19c100008197b4fbed8969eefecdf2d9d5776cf18ab72872f0dff95ac334160b
+  metadata.gz: 9b42751289ba605e41d7e02c85a6a7df99a41a80237ca282a4502d3c4a48198ba8057a35b884a51914b828657a88b1d6c3899d3dd703f10c30a0b9ff779dd364
+  data.tar.gz: 8d627312e95e719ab5ddabbd8bdbd0f964aa0a98ed6372df07f18462ecf69a9bdd4ce1e53f21b29392ad450a5874ebfb6bc5b510bc2adbb5fe634a1edf325cc0

data/lib/solis/graph.rb

@@ -369,6 +369,10 @@ module Solis
 
       @sparql_client = Solis::Store::Sparql::Client.new(@sparql_endpoint)
       result = @sparql_client.query("with <#{graph_name}> delete {?s ?p ?o} where{?s ?p ?o}")
+
+      # Clear the query cache since all data has been flushed
+      Solis::Query.shared_query_cache.clear if defined?(Solis::Query)
+
       LOGGER.info(result)
       true
     end

data/lib/solis/model.rb

@@ -140,6 +140,9 @@ values ?s {<#{self.graph_id}>}
         end
       end
 
+      # Invalidate cached queries for this entity type
+      Solis::Query.invalidate_cache_for(self.class.name)
+
       result
     end
 
@@ -172,6 +175,10 @@ values ?s {<#{self.graph_id}>}
         # Batch check existence of all embedded entities in one query
         existing_ids = self.class.batch_exists?(sparql, all_embedded)
 
+        # Separate embedded entities into creates and updates
+        to_create_embedded = []
+        to_update_embedded = []
+
         all_embedded.each do |embedded|
           entity_exists = existing_ids.include?(embedded.graph_id)
 
@@ -179,23 +186,39 @@ values ?s {<#{self.graph_id}>}
             unless entity_exists
               Solis::LOGGER.warn("#{embedded.class.name} (id: #{embedded.id}) is readonly but does not exist in database. Skipping.")
             end
+          elsif entity_exists
+            to_update_embedded << embedded
           else
-            if entity_exists
-              embedded_data = properties_to_hash(embedded)
-              embedded.update(embedded_data, validate_dependencies, false)
-            else
-              embedded.save(validate_dependencies, false)
-            end
+            to_create_embedded << embedded
           end
         end
 
-        graph = as_graph(self, validate_dependencies)
+        # Batch insert all new embedded entities in one SPARQL INSERT
+        unless to_create_embedded.empty?
+          embedded_graph = RDF::Graph.new
+          embedded_graph.name = RDF::URI(self.class.graph_name)
+          known = {}
+          to_create_embedded.each { |e| collect_known_entities(e, known) }
+          to_create_embedded.each { |e| build_ttl_objekt(embedded_graph, e, [], validate_dependencies, known, skip_store_fetch: true) }
+          sparql.insert_data(embedded_graph, graph: embedded_graph.name)
+        end
+
+        # Updates still processed individually (each needs its own DELETE/INSERT)
+        to_update_embedded.each do |embedded|
+          embedded_data = properties_to_hash(embedded)
+          embedded.update(embedded_data, validate_dependencies, false)
+        end
+
+        graph = as_graph(self, validate_dependencies, {}, skip_store_fetch: true)
 
         Solis::LOGGER.info SPARQL::Client::Update::InsertData.new(graph, graph: graph.name).to_s if ConfigFile[:debug]
 
         result = sparql.insert_data(graph, graph: graph.name)
       end
 
+      # Invalidate cached queries for this entity type
+      Solis::Query.invalidate_cache_for(self.class.name)
+
       after_create_proc&.call(self)
       self
     rescue StandardError => e
@@ -217,7 +240,8 @@ values ?s {<#{self.graph_id}>}
     #   When false (default), uses PUT semantics:
     #   - Embedded entity arrays are fully replaced
     #   - Entities removed from the array are orphaned and deleted if unreferenced
-    def update(data, validate_dependencies = true, top_level = true, sparql_client = nil, patch: false)
+    # @param prefetched_original [Solis::Model, nil] optional pre-fetched original entity to avoid re-querying
+    def update(data, validate_dependencies = true, top_level = true, sparql_client = nil, patch: false, prefetched_original: nil)
       raise Solis::Error::GeneralError, "I need a SPARQL endpoint" if self.class.sparql_endpoint.nil?
 
       attributes = data.include?('attributes') ? data['attributes'] : data
@@ -226,7 +250,7 @@ values ?s {<#{self.graph_id}>}
       id = attributes.delete('id')
       sparql = sparql_client || SPARQL::Client.new(self.class.sparql_endpoint)
 
-      original_klass = self.query.filter({ language: self.class.language, filters: { id: [id] } }).find_all.map { |m| m }&.first
+      original_klass = prefetched_original || self.query.filter({ language: self.class.language, filters: { id: [id] } }).find_all.map { |m| m }&.first
       raise Solis::Error::NotFoundError if original_klass.nil?
       updated_klass = original_klass.deep_dup
 
@@ -250,6 +274,16 @@ values ?s {<#{self.graph_id}>}
       all_embedded = embedded_by_key.values.flatten
       existing_ids = self.class.batch_exists?(sparql, all_embedded)
 
+      # Build lookup of original embedded entities by ID for pre-fetched updates
+      original_embedded_lookup = {}
+      embedded_by_key.each_key do |key|
+        orig = original_klass.instance_variable_get("@#{key}")
+        next if orig.nil?
+        Array(orig).each do |e|
+          original_embedded_lookup[e.id] = e if solis_model?(e) && e.id
+        end
+      end
+
       # Second pass: process embedded entities using batched results
       embedded_by_key.each do |key, embedded_list|
         value = attributes[key]
@@ -280,7 +314,9 @@ values ?s {<#{self.graph_id}>}
           else
             if entity_exists
               embedded_data = properties_to_hash(embedded)
-              embedded.update(embedded_data, validate_dependencies, false)
+              # Pass pre-fetched original to avoid N+1 query in embedded update
+              prefetched = original_embedded_lookup[embedded.id]
+              embedded.update(embedded_data, validate_dependencies, false, nil, prefetched_original: prefetched)
               new_embedded_values << embedded
             else
               embedded_value = embedded.save(validate_dependencies, false)
@@ -328,9 +364,10 @@ values ?s {<#{self.graph_id}>}
         Solis::LOGGER.info("#{original_klass.class.name} unchanged, skipping")
         data = original_klass
       else
-        # Pre-populate known entities to avoid re-fetching during graph building
-        known_entities = { id => original_klass }
-        delete_graph = as_graph(original_klass, false, known_entities)
+        # Pre-populate known entities separately to avoid cross-contamination
+        # between delete and insert graphs (same ID, different attribute values)
+        delete_known = collect_known_entities(original_klass)
+        delete_graph = as_graph(original_klass, false, delete_known)
         where_graph = RDF::Graph.new(graph_name: RDF::URI("#{self.class.graph_name}#{tableized_class_name(self)}/#{id}"), data: RDF::Repository.new)
 
         if id.is_a?(Array)
@@ -341,13 +378,17 @@ values ?s {<#{self.graph_id}>}
           where_graph << [RDF::URI("#{self.class.graph_name}#{tableized_class_name(self)}/#{id}"), :p, :o]
         end
 
-        insert_graph = as_graph(updated_klass, true, known_entities)
+        insert_known = collect_known_entities(updated_klass)
+        insert_graph = as_graph(updated_klass, true, insert_known)
 
         delete_insert_query = SPARQL::Client::Update::DeleteInsert.new(delete_graph, insert_graph, where_graph, graph: insert_graph.name).to_s
         delete_insert_query.gsub!('_:p', '?p')
 
         sparql.query(delete_insert_query)
 
+        # Invalidate cache before verification to avoid stale reads
+        Solis::Query.invalidate_cache_for(self.class.name)
+
         # Verify the update succeeded by re-fetching; fallback to insert if needed
         data = self.query.filter({ filters: { id: [id] } }).find_all.map { |m| m }&.first
         if data.nil?
@@ -359,6 +400,9 @@ values ?s {<#{self.graph_id}>}
         delete_orphaned_entities(entities_to_check_for_deletion, sparql) unless patch
       end
 
+      # Invalidate cached queries for this entity type
+      Solis::Query.invalidate_cache_for(self.class.name)
+
       after_update_proc&.call(updated_klass, data)
 
       data
@@ -384,6 +428,65 @@ values ?s {<#{self.graph_id}>}
       sparql.query("ASK WHERE { <#{self.graph_id}> ?p ?o }")
     end
 
+    # Save multiple entities in a single SPARQL INSERT operation.
+    # Entities that already exist are updated individually.
+    # @param entities [Array<Solis::Model>] entities to save
+    # @param validate_dependencies [Boolean] whether to validate dependencies
+    # @param batch_size [Integer] max entities per INSERT (default 100)
+    # @return [Array<Solis::Model>] the saved entities
+    def self.batch_save(entities, validate_dependencies: true, batch_size: 100)
+      raise "I need a SPARQL endpoint" if sparql_endpoint.nil?
+      return [] if entities.empty?
+
+      sparql = SPARQL::Client.new(sparql_endpoint)
+
+      # Batch check existence of all entities
+      existing_ids = batch_exists?(sparql, entities)
+
+      to_create = []
+      to_update = []
+
+      entities.each do |entity|
+        if existing_ids.include?(entity.graph_id)
+          to_update << entity
+        else
+          to_create << entity
+        end
+      end
+
+      # Batch insert: combine new entity graphs into single INSERT DATA operations
+      unless to_create.empty?
+        to_create.each_slice(batch_size) do |batch|
+          combined_graph = RDF::Graph.new
+          combined_graph.name = RDF::URI(graph_name)
+
+          # Pre-collect known entities from all entities being created
+          known = {}
+          batch.each { |e| e.send(:collect_known_entities, e, known) }
+
+          batch.each do |entity|
+            entity.before_create_proc&.call(entity)
+            entity.send(:build_ttl_objekt, combined_graph, entity, [], validate_dependencies, known, skip_store_fetch: true)
+          end
+
+          sparql.insert_data(combined_graph, graph: combined_graph.name)
+
+          batch.each { |entity| entity.after_create_proc&.call(entity) }
+        end
+
+        # Invalidate cache once for the entity type
+        Solis::Query.invalidate_cache_for(name)
+      end
+
+      # Updates still processed individually (DELETE/INSERT requires per-entity WHERE)
+      to_update.each do |entity|
+        data = entity.send(:properties_to_hash, entity)
+        entity.update(data, validate_dependencies, true, sparql)
+      end
+
+      entities
+    end
+
     # Check existence of multiple entities in a single SPARQL query
     # Returns a Set of graph_ids that exist
     def self.batch_exists?(sparql, entities)
@@ -471,20 +574,22 @@ values ?s {<#{self.graph_id}>}
     end
 
     def self.model(level = 0)
-      m = { type: self.name.tableize, attributes: {} }
+      m = { type: self.name.tableize, attributes: [] }
       self.metadata[:attributes].each do |attribute, attribute_metadata|
-        is_array = ((attribute_metadata[:maxcount].nil? || (attribute_metadata[:maxcount].to_i > 1)) && !attribute_metadata[:datatype].eql?(:lang_string))
-        attribute_name = is_array  ? "#{attribute}[]" : attribute
-        attribute_name = attribute_metadata[:mincount].to_i > 0 ? "#{attribute_name}*" : attribute_name
         if attribute_metadata.key?(:class) && !attribute_metadata[:class].nil? && attribute_metadata[:class].value =~ /#{self.graph_name}/ && level == 0
           cm = self.graph.shape_as_model(self.metadata[:attributes][attribute][:datatype].to_s).model(level + 1)
-          m[:attributes][attribute_name.to_sym] = cm[:attributes]
-        else
-          m[:attributes][attribute_name.to_sym] = { description: attribute_metadata[:comment]&.value,
-                                               mandatory: (attribute_metadata[:mincount].to_i > 0),
-                                               data_type: attribute_metadata[:datatype] }
-          m[:attributes][attribute_name.to_sym][:order] = attribute_metadata[:order]&.value.to_i if attribute_metadata.key?(:order) && !attribute_metadata[:order].nil?
         end
+
+        attribute_data = { name: attribute,
+                           data_type: attribute_metadata[:datatype],
+                           mandatory: (attribute_metadata[:mincount].to_i > 0),
+                           description: attribute_metadata[:comment]&.value
+        }
+        attribute_data[:order] = attribute_metadata[:order]&.value.to_i if attribute_metadata.key?(:order) && !attribute_metadata[:order].nil?
+        attribute_data[:category] = attribute_metadata[:category]&.value if attribute_metadata.key?(:category) && !attribute_metadata[:category].nil?
+        attribute_data[:attributes] = cm[:attributes] if cm && cm[:attributes]
+
+        m[:attributes] << attribute_data
       end
 
       m
@@ -543,6 +648,21 @@ values ?s {<#{self.graph_id}>}
 
     private
 
+    # Walk the entity tree and collect all in-memory entities by UUID.
+    # Prevents redundant store fetches during recursive graph building.
+    def collect_known_entities(entity, collected = {})
+      uuid = entity.instance_variable_get("@id")
+      return collected if uuid.nil? || collected.key?(uuid)
+      collected[uuid] = entity
+      entity.class.metadata[:attributes].each do |attr, meta|
+        next if meta[:node_kind].nil?
+        val = entity.instance_variable_get("@#{attr}")
+        next if val.nil?
+        Array(val).each { |v| collect_known_entities(v, collected) if solis_model?(v) }
+      end
+      collected
+    end
+
     # Helper method to check if an object is a Solis model
     def solis_model?(obj)
       obj.class.ancestors.include?(Solis::Model)
@@ -648,15 +768,15 @@ values ?s {<#{self.graph_id}>}
       Set.new(results.map { |r| r[:o].to_s })
     end
 
-    def as_graph(klass = self, resolve_all = true, known_entities = {})
+    def as_graph(klass = self, resolve_all = true, known_entities = {}, skip_store_fetch: false)
       graph = RDF::Graph.new
       graph.name = RDF::URI(self.class.graph_name)
-      id = build_ttl_objekt(graph, klass, [], resolve_all, known_entities)
+      id = build_ttl_objekt(graph, klass, [], resolve_all, known_entities, skip_store_fetch: skip_store_fetch)
 
       graph
     end
 
-    def build_ttl_objekt(graph, klass, hierarchy = [], resolve_all = true, known_entities = {})
+    def build_ttl_objekt(graph, klass, hierarchy = [], resolve_all = true, known_entities = {}, skip_store_fetch: false)
       hierarchy.push("#{klass.class.name}(#{klass.instance_variables.include?(:@id) ? klass.instance_variable_get("@id") : ''})")
 
       graph_name = self.class.graph_name
@@ -667,9 +787,9 @@ values ?s {<#{self.graph_id}>}
 
       graph << [id, RDF::RDFV.type, klass_metadata[:target_class]]
 
-      # Use cached entity if available, otherwise query the store
+      # Use cached entity if available, otherwise query the store (unless skip_store_fetch)
       original_klass = known_entities[uuid]
-      if original_klass.nil?
+      if original_klass.nil? && !skip_store_fetch
         original_klass = klass.query.filter({ filters: { id: [uuid] } }).find_all { |f| f.id == uuid }.first || nil
       end
 
@@ -689,7 +809,7 @@ values ?s {<#{self.graph_id}>}
       known_entities[uuid] = original_klass
 
       begin
-        make_graph(graph, hierarchy, id, original_klass, klass_metadata, resolve_all, known_entities)
+        make_graph(graph, hierarchy, id, original_klass, klass_metadata, resolve_all, known_entities, skip_store_fetch: skip_store_fetch)
       rescue => e
         Solis::LOGGER.error(e.message)
         raise e
@@ -699,16 +819,16 @@ values ?s {<#{self.graph_id}>}
       id
     end
 
-    def make_graph(graph, hierarchy, id, klass, klass_metadata, resolve_all, known_entities = {})
+    def make_graph(graph, hierarchy, id, klass, klass_metadata, resolve_all, known_entities = {}, skip_store_fetch: false)
       klass_metadata[:attributes].each do |attribute, metadata|
         data = klass.instance_variable_get("@#{attribute}")
 
         if data.nil? && metadata.key?(:mincount) && (metadata[:mincount].nil? || metadata[:mincount] > 0) && graph.query(RDF::Query.new({ attribute.to_sym => { RDF.type => metadata[:node] } })).size == 0
           if data.nil?
             uuid = id.value.split('/').last
-            # Use cached entity if available
+            # Use cached entity if available (skip store fetch for new entities)
             original_klass = known_entities[uuid]
-            if original_klass.nil?
+            if original_klass.nil? && !skip_store_fetch
               original_klass = klass.query.filter({ filters: { id: [uuid] } }).find_all { |f| f.id == uuid }.first || nil
               known_entities[uuid] = original_klass if original_klass
             end
@@ -824,96 +944,6 @@ values ?s {<#{self.graph_id}>}
       raise e
     end
 
-    def build_ttl_objekt_old(graph, klass, hierarchy = [], resolve_all = true)
-      hierarchy.push("#{klass.class.name}(#{klass.instance_variables.include?(:@id) ? klass.instance_variable_get("@id") : ''})")
-      sparql_endpoint = self.class.sparql_endpoint
-      if klass.instance_variables.include?(:@id) && hierarchy.length > 1
-        unless sparql_endpoint.nil?
-          existing_klass = klass.query.filter({ filters: { id: [klass.instance_variable_get("@id")] } }).find_all { |f| f.id == klass.instance_variable_get("@id") }
-          if !existing_klass.nil? && !existing_klass.empty? && existing_klass.first.is_a?(klass.class)
-            klass = existing_klass.first
-          end
-        end
-      end
-
-      uuid = klass.instance_variable_get("@id") || SecureRandom.uuid
-      id = RDF::URI("#{self.class.graph_name}#{klass.class.name.tableize}/#{uuid}")
-      graph << [id, RDF::RDFV.type, klass.class.metadata[:target_class]]
-
-      klass.class.metadata[:attributes].each do |attribute, metadata|
-        data = klass.instance_variable_get("@#{attribute}")
-        if data.nil? && metadata[:datatype_rdf].eql?('http://www.w3.org/2001/XMLSchema#boolean')
-          data = false
-        end
-
-        if metadata[:datatype_rdf].eql?("http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON")
-          data = data.to_json
-        end
-
-        if data.nil? && metadata[:mincount] > 0
-          raise Solis::Error::InvalidAttributeError, "#{hierarchy.join('.')}.#{attribute} min=#{metadata[:mincount]} and max=#{metadata[:maxcount]}"
-        end
-
-        next if data.nil? || ([Hash, Array, String].include?(data.class) && data&.empty?)
-
-        data = [data] unless data.is_a?(Array)
-        model = nil
-        model = klass.class.graph.shape_as_model(klass.class.metadata[:attributes][attribute][:datatype].to_s) unless klass.class.metadata[:attributes][attribute][:node_kind].nil?
-
-        data.each do |d|
-          original_d = d
-          if model
-            target_node = model.metadata[:target_node].value.split('/').last.gsub(/Shape$/, '')
-            if model.ancestors[0..model.ancestors.find_index(Solis::Model) - 1].map { |m| m.name }.include?(target_node)
-              parent_model = model.graph.shape_as_model(target_node)
-            end
-          end
-
-          if model && d.is_a?(Hash)
-            model_instance = model.descendants.map { |m| m&.new(d) rescue nil }.compact.first || nil
-            model_instance = model.new(d) if model_instance.nil?
-
-            if resolve_all
-              d = build_ttl_objekt(graph, model_instance, hierarchy, false, known_entities)
-            else
-              real_model = known_entities[model_instance.id] || model_instance.query.filter({ filters: { id: model_instance.id } }).find_all { |f| f.id == model_instance.id }&.first
-              d = RDF::URI("#{self.class.graph_name}#{real_model ? real_model.class.name.tableize : model_instance.class.name.tableize}/#{model_instance.id}")
-            end
-          elsif model && d.is_a?(model)
-            if resolve_all
-              if parent_model
-                model_instance = parent_model.new({ id: d.id })
-                d = build_ttl_objekt(graph, model_instance, hierarchy, false, known_entities)
-              else
-                d = build_ttl_objekt(graph, d, hierarchy, false, known_entities)
-              end
-            else
-              real_model = known_entities[d.id] || model.new.query.filter({ filters: { id: d.id } }).find_all { |f| f.id == d.id }&.first
-              d = RDF::URI("#{self.class.graph_name}#{real_model ? real_model.class.name.tableize : model.name.tableize}/#{d.id}")
-            end
-          else
-            datatype = RDF::Vocabulary.find_term(metadata[:datatype_rdf] || metadata[:node])
-            if datatype && datatype.datatype?
-              d = if metadata[:datatype_rdf].eql?('http://www.w3.org/1999/02/22-rdf-syntax-ns#langString')
-                    RDF::Literal.new(d, language: self.class.language)
-                  else
-                    if metadata[:datatype_rdf].eql?('http://www.w3.org/2001/XMLSchema#anyURI')
-                      RDF::Literal.new(d.to_s, datatype: RDF::XSD.anyURI)
-                    else
-                      RDF::Literal.new(d, datatype: datatype)
-                    end
-                  end
-              d = (d.object.value rescue d.object) unless d.valid?
-            end
-          end
-
-          graph << [id, RDF::URI("#{self.class.graph_name}#{attribute}"), d]
-        end
-      end
-      hierarchy.pop
-      id
-    end
-
     def properties_to_hash(model)
       n = {}
       model.class.metadata[:attributes].each_key do |m|

data/lib/solis/query.rb

@@ -58,6 +58,30 @@ module Solis
       Solis::Options.instance.get.key?(:graphs) ? Solis::Options.instance.get[:graphs].select{|s| s['type'].eql?(:main)}&.first['name'] : ''
     end
 
+    # Shared class-level query cache to ensure consistent reads/writes/invalidations
+    def self.shared_query_cache
+      cache_dir = File.absolute_path(Solis::Options.instance.get[:cache])
+      @shared_query_cache ||= Moneta.new(:HashFile, dir: cache_dir)
+    end
+
+    # Reset the shared cache (useful when config changes, e.g., in tests)
+    def self.reset_shared_query_cache!
+      @shared_query_cache = nil
+    end
+
+    # Invalidate all cached query results for a given model type.
+    def self.invalidate_cache_for(model_class_name, cache_dir = nil)
+      cache = shared_query_cache
+      tag_key = "TAG:#{model_class_name}"
+      if cache.key?(tag_key)
+        cache[tag_key].each { |key| cache.delete(key) }
+        cache.delete(tag_key)
+        Solis::LOGGER.info("CACHE: invalidated entries for #{model_class_name}") if ConfigFile[:debug]
+      end
+    rescue StandardError => e
+      Solis::LOGGER.warn("CACHE: invalidation failed for #{model_class_name}: #{e.message}")
+    end
+
     def initialize(model)
       @construct_cache = File.absolute_path(Solis::Options.instance.get[:cache])
       @model = model
@@ -73,7 +97,7 @@ module Solis
       @sort = 'ORDER BY ?s'
       @sort_select = ''
       @language = Graphiti.context[:object]&.language || Solis::Options.instance.get[:language] || 'en'
-      @query_cache = Moneta.new(:HashFile, dir: @construct_cache)
+      @query_cache = self.class.shared_query_cache
     end
 
     def each(&block)
@@ -135,6 +159,16 @@ module Solis
 
     private
 
+    # Track a cache key under its model type tag for targeted invalidation
+    def track_cache_key(query_key)
+      tag_key = "TAG:#{@model.model_class_name}"
+      existing_keys = @query_cache.key?(tag_key) ? @query_cache[tag_key] : []
+      unless existing_keys.include?(query_key)
+        existing_keys << query_key
+        @query_cache[tag_key] = existing_keys
+      end
+    end
+
     def model_construct?
       construct_name = @model.model_class_name.tableize.singularize rescue @model.class.name.tableize.singularize
       File.exist?("#{ConfigFile.path}/constructs/#{construct_name}.sparql")
@@ -208,6 +242,9 @@ order by ?s
         Solis::LOGGER.info("CACHE: to #{query_key}") if ConfigFile[:debug]
       end
 
+      # Always ensure the cache key is tracked under its model type tag
+      track_cache_key(query_key)
+
       result
     rescue StandardError => e
       Solis::LOGGER.error(e.message)

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.115.0"
+  VERSION = "0.116.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.115.0
+  version: 0.116.0
 platform: ruby
 authors:
 - Mehmet Celik