solis 0.98.0 → 0.99.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 5b5f53e6ee613f19d1de7527908da768b55623f51f45bdc4ae31ab3ba338a5cc
-  data.tar.gz: d1dfade779a59ad0c36422a20bcc1b8b21fc7c74b75774e1b69be9488050c9ef
+  metadata.gz: 9c57f5cfabe93ada0f5aa3c008ecafa1b130147dfc7ca5b77930362a330a3457
+  data.tar.gz: 7b9854033bb6e4677bde52c4557705f4f48adffe2e0988af33600890c4615984
 SHA512:
-  metadata.gz: ec93a8f1b15c02a1b2b5b52e4f85d0d3058c2528ad73d33d15944e5a3c5609bbfe9e2e83e8ab15efc41c1e98350745903b089cf3902cd2157a3a2aaaeb0f5657
-  data.tar.gz: fd75bb60d80282d6c285b0bb004cdb466a0fa3d6ce2de9960732bb201e5d068c6c4256e7cf560dbf1b67b86371706659f562bc72bb149826285f22cefac6ba84
+  metadata.gz: 6f527bc987723ee900f250c8361a7570df65e3f6238c8ccc560c65097f94e0941a43540222e35e26196f4a70ed94d193040d55f0b2455f38f8ea2b2c39466e2f
+  data.tar.gz: 404047145bf332a80ee0bee495640071137682f009a1a17de7e21b8d531a2b3cf57aec7c704a423366f778c2cc2259267ed1e67f638fc092c38858c611f72a81

data/lib/solis/query/run.rb

@@ -1,75 +1,282 @@
 require 'solis/store/sparql/client'
-require 'solis/query/result_transformer'
 require 'solis/config_file'
 
 class Solis::Query::Runner
   def self.run(entity, query, options = {})
-    sparql_client = Solis::Store::Sparql::Client.new(
-      Solis::Options.instance.get[:sparql_endpoint],
-      graph_name: graph_name
-    )
+    result = {}
 
-    raw_result = sparql_client.query(query, options)
-    model = options[:model] || nil
+    c = Solis::Store::Sparql::Client.new(Solis::Options.instance.get[:sparql_endpoint], graph_name: graph_name)
+    r = c.query(query, options)
 
-    transform_result(raw_result, entity, model)
+    if r.is_a?(SPARQL::Client)
+      result = direct_transform_with_embedding(r, entity, options)
+    else
+      t = r.map(&:to_h)
+      result = sanitize_result({'@graph' => t})
+    end
+    result
   rescue StandardError => e
     puts e.message
     raise e
   end
 
+  def self.direct_transform_with_embedding(client, entity, options = {})
+    results = client.query('select * where{?s ?p ?o}')
+
+    # Step 1: Group all triples by subject
+    grouped = group_by_subject(results)
+
+    # Step 2: Build objects index (without embedding yet)
+    objects_index = build_objects_index(grouped)
+
+    # Step 3: Embed references recursively
+    max_depth = options[:max_embed_depth] || 10
+    root_subjects = find_root_subjects(grouped, entity)
+
+    root_subjects.map do |subject|
+      embed_references(objects_index[subject], objects_index, max_depth, Set.new)
+    end.compact
+  end
+
   private
 
-  def self.transform_result(raw_result, entity, model)
-    if raw_result.is_a?(SPARQL::Client)
-      frame_and_transform(raw_result, entity, model)
-    else
-      transform_select_results(raw_result, model)
+  def self.group_by_subject(results)
+    results.each_with_object({}) do |solution, acc|
+      subject = solution.s.to_s
+      acc[subject] ||= []
+      acc[subject] << { predicate: solution.p, object: solution.o }
     end
   end
 
-  def self.frame_and_transform(sparql_result, entity, model)
-    graph = build_graph_from_result(sparql_result)
-    context = build_context(entity)
+  def self.build_objects_index(grouped)
+    grouped.each_with_object({}) do |(subject, triples), index|
+      obj = {
+        '_id' => subject,                    # Full URI for resolution
+        'id' => nil,                         # Will be set from predicate if exists
+        '@subject' => subject,               # Internal marker for reference resolution
+        '@type' => nil
+      }
+
+      triples.each do |triple|
+        predicate = triple[:predicate]
+        object = triple[:object]
+
+        # Handle rdf:type
+        if predicate.to_s =~ /type$/i || predicate == RDF::RDFV.type
+          obj['@type'] = object.to_s.split('/').last
+          next
+        end
 
-    framed = nil
-    JSON::LD::API.fromRDF(graph) do |expanded|
-      framed = JSON::LD::API.frame(expanded, context)
+        # Get predicate name (last part of URI)
+        pred_name = predicate.to_s.split('/').last.underscore
+
+        # Extract value
+        value = if object.is_a?(RDF::URI)
+                  { '@ref' => object.to_s } # Mark as reference for later resolution
+                else
+                  extract_value(object)
+                end
+
+        # Capture the 'id' predicate value specifically
+        if pred_name == 'id'
+          obj['id'] = value
+          next
+        end
+
+        # Handle multiple values for same predicate
+        if obj.key?(pred_name)
+          obj[pred_name] = [obj[pred_name]] unless obj[pred_name].is_a?(Array)
+          obj[pred_name] << value
+        else
+          obj[pred_name] = value
+        end
+      end
+
+      # Fallback: if no 'id' predicate was found, extract from URI
+      if obj['id'].nil?
+        obj['id'] = subject.split('/').last
+      end
+
+      if obj['@type'].nil?
+        obj['@type'] = subject.split('/')[-2].classify
+      end
+
+      index[subject] = obj
     end
+  end
+
+  def self.find_root_subjects(grouped, entity)
+    # Find subjects that match the requested entity type
+    grouped.select do |subject, triples|
+      type_triple = triples.find { |t| t[:predicate].to_s =~ /type$/i || t[:predicate] == RDF::RDFV.type }
+      next false unless type_triple
 
-    Solis::Query::ResultTransformer.new(model).transform(framed)
+      type_name = type_triple[:object].to_s.split('/').last
+      type_name.downcase == entity.downcase ||
+        type_name.tableize == entity.tableize ||
+        type_name == entity
+    end.keys
   end
 
-  def self.transform_select_results(raw_result, model)
-    results = raw_result.map(&:to_h)
-    Solis::Query::ResultTransformer.new(model).transform({'@graph' => results})
+  def self.embed_references(obj, objects_index, max_depth, visited, current_depth = 0)
+    return nil if obj.nil?
+
+    subject = obj['@subject']
+
+    # At max depth, return minimal reference with both IDs
+    if current_depth >= max_depth
+      #return { '_id' => obj['_id'], 'id' => obj['id'], '@type' => obj['@type'] }
+      return { '_id' => obj['_id'], 'id' => obj['id'] }
+    end
+
+    # Circular reference detection
+    if visited.include?(subject)
+      # Return a reference object instead of embedding
+      #return { '_id' => obj['_id'], 'id' => obj['id'], '@type' => obj['@type'] }
+      return { '_id' => obj['_id'], 'id' => obj['id'] }
+    end
+
+    visited = visited.dup
+    visited.add(subject)
+
+    # Create clean copy without internal markers (except _id)
+    result = {
+      '_id' => obj['_id'],
+      'id' => obj['id']
+    }
+
+    obj.each do |key, value|
+      next if key.start_with?('@')  # Skip internal markers
+      next if key == '_id' || key == 'id'  # Already added
+
+      result[key] = resolve_value(value, objects_index, max_depth, visited, current_depth)
+    end
+
+    result
   end
 
-  def self.build_graph_from_result(sparql_result)
-    graph = RDF::Graph.new
-    sparql_result.query('select * where{?s ?p ?o}').each do |statement|
-      graph << [statement.s, statement.p, statement.o]
+  def self.resolve_value(value, objects_index, max_depth, visited, current_depth)
+    case value
+    when Array
+      value.map { |v| resolve_value(v, objects_index, max_depth, visited, current_depth) }
+    when Hash
+      if value.key?('@ref')
+        # This is a reference - try to embed it
+        ref_uri = value['@ref']
+        referenced_obj = objects_index[ref_uri]
+
+        if referenced_obj
+          embed_references(referenced_obj, objects_index, max_depth, visited, current_depth + 1)
+        else
+          # External reference - return both IDs
+          { '_id' => ref_uri, 'id' => ref_uri.split('/').last }
+        end
+      else
+        # Regular hash - recurse
+        value.transform_values { |v| resolve_value(v, objects_index, max_depth, visited, current_depth) }
+      end
+    else
+      value
     end
-    graph
   end
 
-  def self.build_context(entity)
-    JSON.parse(%(
-{
-  "@context": {
-    "@vocab": "#{graph_name}",
-    "id": "@id"
-  },
-  "@type": "#{entity}",
-  "@embed": "@always"
-}
-    ))
+  def self.extract_value(literal)
+    return literal.to_s if literal.is_a?(RDF::URI)
+
+    datatype = literal.datatype&.to_s
+
+    case datatype
+    when "http://www.w3.org/2001/XMLSchema#dateTime"
+      DateTime.parse(literal.value)
+    when "http://www.w3.org/2001/XMLSchema#date"
+      Date.parse(literal.value)
+    when "http://www.w3.org/2001/XMLSchema#boolean"
+      literal.value == "true"
+    when "http://www.w3.org/2001/XMLSchema#integer", "http://www.w3.org/2001/XMLSchema#int"
+      literal.value.to_i
+    when "http://www.w3.org/2001/XMLSchema#float", "http://www.w3.org/2001/XMLSchema#double", "http://www.w3.org/2001/XMLSchema#decimal"
+      literal.value.to_f
+    when "http://www.w3.org/2006/time#DateTimeInterval"
+      ISO8601::TimeInterval.parse(literal.value).to_s
+    when "http://www.w3.org/1999/02/22-rdf-syntax-ns#JSON"
+      JSON.parse(literal.value) rescue literal.value
+    else
+      # Handle language-tagged strings
+      if literal.respond_to?(:language) && literal.language
+        { '@value' => literal.value, '@language' => literal.language.to_s }
+      else
+        literal.value
+      end
+    end
+  rescue StandardError => e
+    Solis::LOGGER.warn("Error extracting value: #{e.message}")
+    literal.to_s
   end
 
   def self.graph_name
-    graphs = Solis::Options.instance.get[:graphs]
-    raise Solis::Error::NotFoundError, 'No graph name found' if graphs.nil?
+    Solis::Options.instance.get.key?(:graphs) ? Solis::Options.instance.get[:graphs].select { |s| s['type'].eql?(:main) }&.first['name'] : ''
+  end
+
+  # Keep original methods for backward compatibility
+  def self.sanitize_result(framed)
+    data = framed&.key?('@graph') ? framed['@graph'] : [framed]
+    sanitatize_data_in_result(data)
+  end
 
-    graphs.find { |g| g['type'].eql?(:main) }&.fetch('name') || ''
+  def self.sanitatize_data_in_result(data)
+    data.map do |d|
+      d.delete_if { |e| e =~ /^@/ }
+      if d.is_a?(Hash)
+        new_d = {}
+        d.each do |k, v|
+          if v.is_a?(Hash)
+            if v.key?('@type')
+              type = v['@type']
+              if v.key?('@value')
+                value = v['@value']
+                case type
+                when "http://www.w3.org/2001/XMLSchema#dateTime"
+                  value = DateTime.parse(value)
+                when "http://www.w3.org/2001/XMLSchema#date"
+                  value = Date.parse(value)
+                when "http://www.w3.org/2006/time#DateTimeInterval"
+                  value = ISO8601::TimeInterval.parse(value)
+                when "http://www.w3.org/2001/XMLSchema#boolean"
+                  value = value == "true"
+                end
+                v = value
+              end
+              v = sanitize_result(v) if v.is_a?(Hash)
+            end
+            if v.is_a?(Hash)
+              new_d[k] = v.class.method_defined?(:value) ? v.value : sanitize_result(v)
+            else
+              new_d[k] = v.class.method_defined?(:value) ? v.value : v
+            end
+          elsif v.is_a?(Array)
+            new_d[k] = []
+            v.each do |vt|
+              if vt.is_a?(Hash)
+                if vt.key?('@value')
+                  new_d[k] << vt['@value']
+                else
+                  new_d[k] << (vt.is_a?(String) ? vt : sanitize_result(vt))
+                end
+              else
+                new_d[k] << (vt.is_a?(String) ? vt : sanitize_result(vt))
+              end
+            end
+            new_d[k].flatten!
+          else
+            new_d[k] = v.class.method_defined?(:value) ? v.value : v
+          end
+        end
+        d = new_d
+      end
+      d
+    end
+  rescue StandardError => e
+    Solis::LOGGER.error(e.message)
+    data
   end
 end

data/lib/solis/version.rb

@@ -1,3 +1,3 @@
 module Solis
-  VERSION = "0.98.0"
+  VERSION = "0.99.0"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: solis
 version: !ruby/object:Gem::Version
-  version: 0.98.0
+  version: 0.99.0
 platform: ruby
 authors:
 - Mehmet Celik
@@ -299,7 +299,6 @@ files:
 - lib/solis/query.rb
 - lib/solis/query/construct.rb
 - lib/solis/query/filter.rb
-- lib/solis/query/result_transformer.rb
 - lib/solis/query/run.rb
 - lib/solis/resource.rb
 - lib/solis/shape.rb

data/lib/solis/query/result_transformer.rb

@@ -1,130 +0,0 @@
-class Solis::Query::ResultTransformer
-  def initialize(model)
-    @model = model
-    @type_mappings = load_type_mappings
-    @cardinality_map = build_cardinality_map
-  end
-
-  def transform(data)
-    items = data.key?('@graph') ? data['@graph'] : [data]
-    items.map { |item| transform_item(item) }
-  end
-
-  private
-
-  def transform_item(item)
-    clean_item = remove_json_ld_metadata(item)
-    cast_and_shape(clean_item)
-  end
-
-  def cast_and_shape(item)
-    item.each_with_object({}) do |(key, value), result|
-      value = cast_value(value)
-      result[key] = enforce_cardinality(key, value)
-    end
-  end
-
-  # def cast_and_shape(item)
-  #   item.each_with_object({}) do |(key, value), result|
-  #     value = cast_value(value)
-  #     value = enforce_cardinality(key, value)
-  #     value = transform_nested_entity(key, value)
-  #     result[key] = value
-  #   end
-  # end
-
-  def transform_nested_entity(property_key, value)
-    return value if @model.nil?
-
-    metadata = @cardinality_map[property_key]
-    return value if metadata.nil?
-
-    datatype = metadata[:datatype]
-    node = metadata[:node]
-
-    # Check if datatype points to another entity (has a node)
-    if node.is_a?(RDF::URI) && value.is_a?(Hash)
-      # Recursively transform nested entity if we have its model
-      # You'd need a way to resolve the node URI to the model class
-      nested_model = resolve_model_from_node(datatype)
-      Solis::Query::ResultTransformer.new(nested_model).transform(value) if nested_model
-    elsif value.is_a?(Array) && value.all?(Hash)
-      # Transform array of nested entities
-      value.map { |v| transform_nested_entity(property_key, v) }
-    else
-      value
-    end
-  end
-
-  def resolve_model_from_node(datatype_node)
-    @model.graph.shape_as_model(datatype_node.to_s)
-  end
-
-
-  def remove_json_ld_metadata(item)
-    item.reject { |key| key.start_with?('@') }
-  end
-
-  def cast_value(value)
-    case value
-    when Hash
-      handle_typed_value(value)
-    when Array
-      value.map { |v| cast_value(v) }
-    else
-      value
-    end
-  end
-
-  def handle_typed_value(value)
-    return value unless value.key?('@type') && value.key?('@value')
-
-    type = value['@type']
-    raw_value = value['@value']
-
-    cast_by_type(type, raw_value)
-  end
-
-  def cast_by_type(type, value)
-    caster = @type_mappings[type]
-    caster ? caster.call(value) : value
-  end
-
-  def enforce_cardinality(property_key, value)
-    return value if @model.nil?
-
-    metadata = @cardinality_map[property_key]
-    return value if metadata.nil?
-
-    maxcount = metadata[:maxcount]
-
-    # If maxcount is nil or > 1, ensure it's an array
-    if maxcount.nil? || maxcount > 1
-      value.is_a?(Array) ? value : [value]
-      # If maxcount is 0 or 1, ensure it's a single value
-    else
-      value.is_a?(Array) ? value.first : value
-    end
-  end
-
-  def build_cardinality_map
-    return {} if @model.nil? || @model.metadata.nil?
-
-    attributes = @model.metadata[:attributes] || {}
-
-    attributes.each_with_object({}) do |(property_name, property_metadata), map|
-      map[property_name.to_s] = property_metadata
-    end
-  end
-
-  def load_type_mappings
-    {
-      "http://www.w3.org/2001/XMLSchema#dateTime" => ->(v) { DateTime.parse(v) },
-      "http://www.w3.org/2001/XMLSchema#date" => ->(v) { Date.parse(v) },
-      "http://www.w3.org/2006/time#DateTimeInterval" => ->(v) { ISO8601::TimeInterval.parse(v) },
-      "http://www.w3.org/2001/XMLSchema#boolean" => ->(v) { v == "true" },
-      "http://www.w3.org/2001/XMLSchema#integer" => ->(v) { v.to_i },
-      "http://www.w3.org/2001/XMLSchema#decimal" => ->(v) { BigDecimal(v) }
-    }
-  end
-end