solis 0.115.0 → 0.117.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c9039f8bba386333b11237b9914c7fdeee57ad8094ea57058815f2fc008d4a7
-  data.tar.gz: ea7269d0380b39c1a88a7d064c503c972194a548441c6c32459ab4ca7187cab8
+  metadata.gz: fa9ba6d86b36ebd75e9e0280928ce458f1ae70e4c64f44832c0963870f319b2f
+  data.tar.gz: 23c8bd2bcbbb4fe97dc133b3310d1527bab161dbce43e2939b45a8fa1a9b7712
 SHA512:
-  metadata.gz: 17d2aa3f39b2bee0cb267996467ba8a0fe08d433e3e63c9dbab3df8624cac6ebf45703bc90c606f3c7d90d4c0ab12b72c3794056c11481f008141c456fe27675
-  data.tar.gz: 0e9faa327c21a51aa3413ed0d90c20f781186c360ae4e33c3d2b6432c1e9779e19c100008197b4fbed8969eefecdf2d9d5776cf18ab72872f0dff95ac334160b
+  metadata.gz: f15183cf04d168b3d06425bfe987d4cc446d0fad1e1b1f94532b8dfedf39b3401d39641226d91a63400f4a4e1c7096a0c995b64e2629d6d07424bae7e4c14375
+  data.tar.gz: d7219d14c2290aa045ca80a32a97df1f12fcc4aa0df31fc3628fe91dbd5e2ee7e6239474aef27f4f43caf45fb9347e8cd059a0deabff12a3b2bd754ad1e98342

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,23 @@ 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),
+                           repeatable: (attribute_metadata[:maxcount].to_i > 1 || attribute_metadata[:maxcount].nil?),
+                           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[:group] = attribute_metadata[:group]&.value.gsub(graph_name,'').gsub(/Group$/,'') if attribute_metadata.key?(:group) && !attribute_metadata[:group].nil?
+        attribute_data[:attributes] = cm[:attributes] if cm && cm[:attributes]
+
+        m[:attributes] << attribute_data
       end
 
       m
@@ -543,6 +649,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 +769,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 +788,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 +810,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 +820,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 +945,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/shape/reader/sheet.rb

@@ -52,28 +52,20 @@ module Solis
             end
 
             def read_sheets(key, spreadsheet_id, options)
-              data = nil
               prefixes = options[:prefixes] || nil
               metadata = options[:metadata] || nil
 
-              cache_dir = ConfigFile.include?(:cache) ? ConfigFile[:cache] : '/tmp'
-
-              if ::File.exist?("#{cache_dir}/#{spreadsheet_id}.json") && (options.include?(:from_cache) && options[:from_cache])
-                Solis::LOGGER.info("from cache #{cache_dir}/#{spreadsheet_id}.json")
-                data = JSON.parse(::File.read("#{cache_dir}/#{spreadsheet_id}.json"), { symbolize_names: true })
-                return data
-              else
-                Solis::LOGGER.info("from source #{spreadsheet_id}")
-                session = SimpleSheets.new(key, spreadsheet_id)
-                session.key = key
-                sheets = {}
-                session.worksheets.each do |worksheet|
-                  sheet = ::Sheet.new(worksheet)
-                  sheets[sheet.title] = sheet
-                end
-
-                validate(sheets, prefixes, metadata)
+              Solis::LOGGER.info("from source #{spreadsheet_id}")
+              session = SimpleSheets.new(key, spreadsheet_id)
+              session.key = key
+              sheets = {}
+              session.worksheets.each do |worksheet|
+                sheet = ::Sheet.new(worksheet)
+                sheets[sheet.title] = sheet
               end
+
+              validate(sheets, prefixes, metadata)
+
               sheets
             end
 
@@ -118,6 +110,7 @@ module Solis
 
                 entities.store(e['name'].to_sym, { description: e['description'],
                                                    order: e['order'],
+                                                   category: e['categories'],
                                                    plural: e['nameplural'],
                                                    label: e['name'].to_s.strip,
                                                    sub_class_of: e['subclassof'].nil? || e['subclassof'].empty? ? [] : [e['subclassof']],
@@ -137,12 +130,6 @@ module Solis
                 metadata: ontology_metadata
               }
 
-              cache_dir = ConfigFile.include?(:cache) ? ConfigFile[:cache] : '/tmp'
-              # ::File.open("#{::File.absolute_path(cache_dir)}/#{spreadsheet_id}.json", 'wb') do |f|
-              ::File.open("#{::File.absolute_path(cache_dir)}/#{sheet_id}.json", 'wb') do |f|
-                f.puts data.to_json
-              end
-
               data
             rescue StandardError => e
               raise Solis::Error::GeneralError, e.message
@@ -180,6 +167,7 @@ module Solis
                       cardinality: { min: min_max['min'], max: min_max['max'] },
                       same_as: p['sameas'],
                       order: p['order'],
+                      category: p['categories'],
                       description: p['description']
                     }
 
@@ -302,6 +290,8 @@ hide empty members
                     node = target_class
                   end
 
+                  groups = {}
+
                   out += %(
 #{graph_prefix}:#{entity_name}Shape
     a               #{shacl_prefix}:NodeShape ;
@@ -322,11 +312,19 @@ hide empty members
                     min_count = property_metadata[:cardinality][:min].strip
                     max_count = property_metadata[:cardinality][:max].strip
                     order = property_metadata.key?(:order) && property_metadata[:order] ? property_metadata[:order]&.strip : nil
+                    category = property_metadata.key?(:category) && property_metadata[:category] ? property_metadata[:category]&.strip : nil
+                    category = category.nil? || category.empty? ? nil : category
+
+                    unless category.nil?
+                      group = "#{category.classify}Group"
+                      groups[group] = category unless groups.key?(group)
+                    end
 
                     if datatype =~ /^#{graph_prefix}:/ || datatype =~ /^<#{graph_name}/
                       out += %(    #{shacl_prefix}:property [#{shacl_prefix}:path #{path} ;
                  #{shacl_prefix}:name "#{attribute}" ;
                  #{shacl_prefix}:description "#{description}" ;#{order.nil? ? '' : "\n                 #{shacl_prefix}:order #{order} ;"}
+                 #{category.nil? ? '' : "\n                 #{shacl_prefix}:group #{graph_prefix}:#{group} ;"}
                  #{shacl_prefix}:nodeKind #{shacl_prefix}:IRI ;
                  #{shacl_prefix}:class    #{datatype} ;#{min_count =~ /\d+/ ? "\n                 #{shacl_prefix}:minCount #{min_count} ;" : ''}#{max_count =~ /\d+/ ? "\n                 #{shacl_prefix}:maxCount #{max_count} ;" : ''}
     ] ;
@@ -344,6 +342,7 @@ hide empty members
                         out += %(    #{shacl_prefix}:property [#{shacl_prefix}:path #{path} ;
                  #{shacl_prefix}:name "#{attribute}";
                  #{shacl_prefix}:description "#{description}" ;#{order.nil? ? '' : "\n                 #{shacl_prefix}:order #{order} ;"}
+                 #{category.nil? ? '' : "\n                 #{shacl_prefix}:group #{graph_prefix}:#{group} ;"}
                  #{shacl_prefix}:datatype #{datatype} ;#{min_count =~ /\d+/ ? "\n                 #{shacl_prefix}:minCount #{min_count} ;" : ''}#{max_count =~ /\d+/ ? "\n                 #{shacl_prefix}:maxCount #{max_count} ;" : ''}
     ] ;
 )
@@ -359,6 +358,15 @@ hide empty members
                     end
                   end
                   out += ".\n"
+
+                  groups.each do |group, category|
+                    out += %(
+#{graph_prefix}:#{group}
+	a sh:PropertyGroup ;
+	rdfs:label "#{category}" .
+
+)
+                  end
                 end
               end
               out
@@ -716,6 +724,14 @@ hide empty members
             end
           end
 
+          cache_dir = ConfigFile.include?(:cache) ? ConfigFile[:cache] : '/tmp'
+          cache_file = "#{::File.absolute_path(cache_dir)}/#{spreadsheet_id}.json"
+
+          if options[:from_cache] && ::File.exist?(cache_file)
+            Solis::LOGGER.info("Loading cached result from #{cache_file}")
+            return JSON.parse(::File.read(cache_file), symbolize_names: true)
+          end
+
           sheet_data = read_sheets(key, spreadsheet_id, options)
           prefixes = sheet_data['_PREFIXES']
           metadata = sheet_data['_METADATA']
@@ -736,10 +752,6 @@ hide empty members
               { sheet_url: reference['sheeturl'], description: reference['description'] }
             end
 
-            cache_dir = ConfigFile.include?(:cache) ? ConfigFile[:cache] : '/tmp'
-            ::File.open("#{::File.absolute_path(cache_dir)}/#{spreadsheet_id}.json", 'wb') do |f|
-              f.puts references.to_json
-            end
           else
             references = sheet_data
           end
@@ -778,7 +790,16 @@ hide empty members
           Solis::LOGGER.info('Generating JSON SCHEMA')
           json_schema = build_json_schema(shacl)
 
-          { inflections: inflections, shacl: shacl, schema: schema, plantuml: plantuml, json_schema: json_schema }
+          result = { inflections: inflections, shacl: shacl, schema: schema, plantuml: plantuml, json_schema: json_schema }
+
+          begin
+            ::File.open(cache_file, 'wb') { |f| f.puts result.to_json }
+            Solis::LOGGER.info("Cached result to #{cache_file}")
+          rescue StandardError => e
+            Solis::LOGGER.warn("Failed to write cache: #{e.message}")
+          end
+
+          result
         end
       end
     end

data/lib/solis/shape.rb

@@ -104,6 +104,7 @@ module Solis
           attribute_class = solution.attributeClass if solution.bound?(:attributeClass)
           attribute_comment = solution.attributeComment if solution.bound?(:attributeComment)
           attribute_order = solution.attributeOrder if solution.bound?(:attributeOrder)
+          attribute_group = solution.attributeGroup if solution.bound?(:attributeGroup)
 
           attribute_max_count =  1 if solution.bound?(:attributeUniqueLang) && solution.attributeUniqueLang.value.eql?('true')
 
@@ -125,6 +126,7 @@ module Solis
             mincount: attribute_min_count,
             maxcount: attribute_max_count,
             order: attribute_order,
+            group: attribute_group,
             node: attribute_node,
             node_kind: attribute_node_kind,
             class: attribute_class,
@@ -142,7 +144,7 @@ PREFIX rdfv: <http://www.w3.org/1999/02/22-rdf-syntax-ns#>
 
 SELECT ?targetClass ?targetNode ?comment ?className ?attributePath ?attributeName ?attributeDatatype
        ?attributeMinCount ?attributeMaxCount ?attributeOr ?attributeClass
-       ?attributeNode ?attributeNodeKind ?attributeComment ?attributeOrder ?attributeUniqueLang ?o
+       ?attributeNode ?attributeNodeKind ?attributeComment ?attributeOrder ?attributeGroup ?attributeUniqueLang ?o
 WHERE {
 
   ?s a sh:NodeShape;
@@ -162,6 +164,7 @@ WHERE {
                            OPTIONAL{ ?attributes sh:node     ?attributeNode } .
                            OPTIONAL{ ?attributes sh:description ?attributeComment } .
                            OPTIONAL{ ?attributes sh:order ?attributeOrder } .
+                           OPTIONAL{ ?attributes sh:group ?attributeGroup } .
                            OPTIONAL{ ?attributes sh:uniqueLang ?attributeUniqueLang } .
      }.
 }
@@ -182,6 +185,7 @@ WHERE {
                     "mincount": 1,
                     "maxcount": 1,
                     "order": nil,
+                    "group": nil,
                     "node": nil,
                     "node_kind": nil,
                     "class": nil,

data/lib/solis/version.rb

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

metadata

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