noiseless 0.7.2 → 0.9.0

data/lib/noiseless/introspection/query_visualizer.rb

@@ -64,9 +64,9 @@ module Noiseless
         when :yaml
           YAML.dump(ast_node.to_h)
         when :mermaid
-          ast_to_mermaid_flowchart(ast_node)
+          MermaidDiagrams.ast_to_mermaid_flowchart(ast_node)
         when :mermaid_class
-          ast_to_mermaid_class_diagram(ast_node)
+          MermaidDiagrams.ast_to_mermaid_class_diagram(ast_node)
         else
           raise ArgumentError, "Unsupported format: #{format}. Available: :tree, :json, :yaml, :mermaid, :mermaid_class"
         end
@@ -75,7 +75,7 @@ module Noiseless
       def self.explain_query_flow(ast_node, adapter)
         explanation = adapter.explain_query(ast_node)
 
-        flow_diagram = generate_flow_diagram(explanation)
+        flow_diagram = MermaidDiagrams.generate_flow_diagram(explanation)
 
         {
           explanation: explanation,
@@ -230,68 +230,6 @@ module Noiseless
         end
       end
 
-      def self.generate_mermaid_diagram(ast_node)
-        diagram = "graph TD\n".dup
-
-        add_node = lambda do |diagram, node, parent_id, counter|
-          case node
-          when Hash
-            node.each do |key, value|
-              current_id = "N#{counter[:count]}"
-              counter[:count] += 1
-              diagram << "  #{current_id}[#{key}]\n"
-              diagram << "  #{parent_id} --> #{current_id}\n" if parent_id
-              add_node.call(diagram, value, current_id, counter)
-            end
-          when Array
-            node.each_with_index do |item, index|
-              current_id = "N#{counter[:count]}"
-              counter[:count] += 1
-              diagram << "  #{current_id}[Item #{index}]\n"
-              diagram << "  #{parent_id} --> #{current_id}\n" if parent_id
-              add_node.call(diagram, item, current_id, counter)
-            end
-          else
-            current_id = "N#{counter[:count]}"
-            counter[:count] += 1
-            diagram << "  #{current_id}[#{node}]\n"
-            diagram << "  #{parent_id} --> #{current_id}\n" if parent_id
-          end
-        end
-
-        counter = { count: 0 }
-        root_id = "N#{counter[:count]}"
-        counter[:count] += 1
-        diagram << "  #{root_id}[Root]\n"
-
-        add_node.call(diagram, ast_node.to_h, root_id, counter)
-        diagram
-      end
-
-      def self.generate_flow_diagram(explanation)
-        # Create a sequence diagram showing the query execution flow
-        diagram = "sequenceDiagram\n".dup
-        diagram << "    participant Client\n"
-        diagram << "    participant Adapter\n"
-        diagram << "    participant Engine\n"
-
-        explanation[:execution_plan].each do |step|
-          diagram << case step[:description]
-                     when /validate/i
-                       "    Client->>Adapter: #{step[:description]}\n"
-                     when /convert/i, /format/i
-                       "    Adapter->>Adapter: #{step[:description]}\n"
-                     when /execute/i, /query/i
-                       "    Adapter->>Engine: #{step[:description]}\n"
-                     else
-                       "    Engine->>Adapter: #{step[:description]}\n"
-                     end
-        end
-
-        diagram << "    Adapter->>Client: Return results\n"
-        diagram
-      end
-
       def self.format_performance_breakdown(performance)
         performance.map do |metric, value|
           {
@@ -365,169 +303,6 @@ module Noiseless
           node.each { |item| count_recursive(item, complexity) }
         end
       end
-
-      # New methods using your diagram/mermaid gems
-      def self.ast_to_mermaid_flowchart(ast_node)
-        return "# Mermaid diagrams require 'diagrams' and 'mermaid' gems\n# Add to Gemfile: gem 'diagrams'; gem 'mermaid'" unless DIAGRAMS_AVAILABLE
-
-        diagram = Diagrams::FlowchartDiagram.new(version: "1.0")
-
-        # Convert AST structure to flowchart nodes and edges
-        add_ast_node_to_flowchart(diagram, ast_node, "root")
-
-        diagram.to_mermaid
-      end
-
-      def self.ast_to_mermaid_class_diagram(ast_node)
-        return "# Mermaid diagrams require 'diagrams' and 'mermaid' gems\n# Add to Gemfile: gem 'diagrams'; gem 'mermaid'" unless DIAGRAMS_AVAILABLE
-
-        diagram = Diagrams::ClassDiagram.new(version: "1.0")
-
-        # Create a class representation of the AST structure
-        root_class = Diagrams::Elements::ClassEntity.new(
-          name: ast_node.class.name.split("::").last,
-          attributes: ast_node.instance_variables.map do |var|
-            "#{var.to_s.delete('@')}: #{ast_node.instance_variable_get(var).class.name.split('::').last}"
-          end,
-          methods: ast_node.public_methods(false).map { |method| "+#{method}()" }
-        )
-
-        diagram.add_class(root_class)
-
-        # Add child nodes as related classes
-        add_ast_children_to_class_diagram(diagram, ast_node, root_class.name)
-
-        diagram.to_mermaid
-      end
-
-      def self.adapter_capability_matrix_to_mermaid
-        return "# Mermaid diagrams require 'diagrams' and 'mermaid' gems\n# Add to Gemfile: gem 'diagrams'; gem 'mermaid'" unless DIAGRAMS_AVAILABLE
-
-        # Create an ER diagram showing adapter capabilities
-        diagram = Diagrams::ERDiagram.new
-
-        # Add adapter entities
-        diagram.add_entity(
-          name: "ADAPTER",
-          attributes: [
-            { type: "string", name: "type", keys: [:PK] },
-            { type: "string", name: "execution_mode" },
-            { type: "string", name: "engine_name" }
-          ]
-        )
-
-        diagram.add_entity(
-          name: "CAPABILITY",
-          attributes: [
-            { type: "string", name: "name", keys: [:PK] },
-            { type: "string", name: "description" }
-          ]
-        )
-
-        diagram.add_entity(
-          name: "ADAPTER_CAPABILITY",
-          attributes: [
-            { type: "string", name: "adapter_type", keys: %i[PK FK] },
-            { type: "string", name: "capability_name", keys: %i[PK FK] }
-          ]
-        )
-
-        # Add relationships
-        diagram.add_relationship(
-          entity1: "ADAPTER",
-          entity2: "ADAPTER_CAPABILITY",
-          cardinality1: :ONE_ONLY,
-          cardinality2: :ZERO_OR_MORE,
-          label: "has"
-        )
-
-        diagram.add_relationship(
-          entity1: "CAPABILITY",
-          entity2: "ADAPTER_CAPABILITY",
-          cardinality1: :ONE_ONLY,
-          cardinality2: :ZERO_OR_MORE,
-          label: "provided by"
-        )
-
-        diagram.to_mermaid
-      end
-
-      def self.add_ast_node_to_flowchart(diagram, node, node_id)
-        # Add current node
-        flowchart_node = Diagrams::Elements::Node.new(
-          id: node_id,
-          label: node.class.name.split("::").last.to_s
-        )
-        diagram.add_node(flowchart_node)
-
-        # Add child nodes and connect them
-        return unless node.respond_to?(:instance_variables)
-
-        node.instance_variables.each_with_index do |var, _index|
-          child_value = node.instance_variable_get(var)
-
-          if child_value.is_a?(Noiseless::AST::Node)
-            child_id = "#{node_id}_#{var.to_s.delete('@')}"
-            add_ast_node_to_flowchart(diagram, child_value, child_id)
-
-            edge = Diagrams::Elements::Edge.new(
-              source_id: node_id,
-              target_id: child_id,
-              label: var.to_s.delete("@")
-            )
-            diagram.add_edge(edge)
-          elsif child_value.is_a?(Array) && child_value.any?(Noiseless::AST::Node)
-            child_value.each_with_index do |item, item_index|
-              next unless item.is_a?(Noiseless::AST::Node)
-
-              child_id = "#{node_id}_#{var.to_s.delete('@')}_#{item_index}"
-              add_ast_node_to_flowchart(diagram, item, child_id)
-
-              edge = Diagrams::Elements::Edge.new(
-                source_id: node_id,
-                target_id: child_id,
-                label: "#{var.to_s.delete('@')}[#{item_index}]"
-              )
-              diagram.add_edge(edge)
-            end
-          end
-        end
-      end
-
-      def self.add_ast_children_to_class_diagram(diagram, node, parent_class_name)
-        return unless node.respond_to?(:instance_variables)
-
-        node.instance_variables.each do |var|
-          child_value = node.instance_variable_get(var)
-
-          next unless child_value.is_a?(Noiseless::AST::Node)
-
-          child_class_name = child_value.class.name.split("::").last
-
-          # Add child class if not already added
-          unless diagram.classes.any? { |c| c.name == child_class_name }
-            child_class = Diagrams::Elements::ClassEntity.new(
-              name: child_class_name,
-              attributes: child_value.instance_variables.map do |cv|
-                "#{cv.to_s.delete('@')}: #{child_value.instance_variable_get(cv).class.name.split('::').last}"
-              end
-            )
-            diagram.add_class(child_class)
-          end
-
-          # Add relationship
-          relationship = Diagrams::Elements::Relationship.new(
-            source_class_name: parent_class_name,
-            target_class_name: child_class_name,
-            type: "composition",
-            label: var.to_s.delete("@")
-          )
-          diagram.add_relationship(relationship)
-
-          # Recursively add children
-          add_ast_children_to_class_diagram(diagram, child_value, child_class_name)
-        end
-      end
     end
   end
 end

data/lib/noiseless/introspection.rb

@@ -45,7 +45,7 @@ module Noiseless
       # Engine-specific capabilities
       case self.class.name
       when /OpenSearch/
-        capabilities += %i[point_in_time_search search_templates] if respond_to?(:point_in_time_search)
+        capabilities += %i[point_in_time_pagination search_templates] if respond_to?(:each_page)
       when /Typesense/
         capabilities += %i[typo_tolerance faceted_search] if respond_to?(:faceted_search)
       when /Elasticsearch/

data/lib/noiseless/log_subscriber.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Noiseless
+  # Log subscriber for Rails integration
+  class LogSubscriber < ActiveSupport::LogSubscriber
+    def search(event)
+      return unless logger.debug?
+
+      indexes = event.payload[:indexes]&.join(", ") || "unknown"
+      duration = event.duration.round(2)
+
+      debug "Noiseless Search (#{duration}ms) indexes=[#{indexes}] #{query_summary(event.payload[:query])}"
+    end
+
+    def bulk(event)
+      return unless logger.debug?
+
+      actions_count = event.payload[:actions_count] || 0
+      duration = event.duration.round(2)
+
+      debug "Noiseless Bulk (#{duration}ms) actions=#{actions_count}"
+    end
+
+    def index_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Index Document (#{duration}ms) index=#{index} id=#{id}"
+    end
+
+    def update_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      changes_count = event.payload[:changes_count] || 0
+      duration = event.duration.round(2)
+
+      debug "Noiseless Update Document (#{duration}ms) index=#{index} id=#{id} changes=#{changes_count}"
+    end
+
+    def delete_document(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      id = event.payload[:id]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Delete Document (#{duration}ms) index=#{index} id=#{id}"
+    end
+
+    def create_index(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Create Index (#{duration}ms) index=#{index}"
+    end
+
+    def delete_index(event)
+      return unless logger.debug?
+
+      index = event.payload[:index]
+      duration = event.duration.round(2)
+
+      debug "Noiseless Delete Index (#{duration}ms) index=#{index}"
+    end
+
+    private
+
+    def query_summary(query)
+      return "empty" unless query.is_a?(Hash)
+
+      parts = []
+
+      if query[:query]&.dig(:bool, :must)&.any?
+        must_count = query[:query][:bool][:must].size
+        parts << "must:#{must_count}"
+      end
+
+      if query[:query]&.dig(:bool, :filter)&.any?
+        filter_count = query[:query][:bool][:filter].size
+        parts << "filter:#{filter_count}"
+      end
+
+      if query[:sort]&.any?
+        sort_count = query[:sort].size
+        parts << "sort:#{sort_count}"
+      end
+
+      if query[:from] || query[:size]
+        parts << "from:#{query[:from] || 0}"
+        parts << "size:#{query[:size] || 20}"
+      end
+
+      parts.join(" ")
+    end
+  end
+end

data/lib/noiseless/model.rb

@@ -3,6 +3,25 @@
 module Noiseless
   class Model
     extend DSL::ClassMethods
+    extend QueryDelegation
+
+    delegate_query_methods :match, :multi_match, :filter, :range, :sort, :limit, :offset, :paginate,
+                           :aggregation, :geo_distance, :indexes, :remove_duplicates, :facet_sample_slope, :pinned_hits,
+                           to: :@builder
+
+    # Explicit mapping: index names may be aliases, not record class names.
+    # String names are resolved on read so Rails can reload the record class.
+    def self.record_class(value = nil)
+      unless value.nil?
+        raise ArgumentError, "record_class must be a Class or a class name String" unless value.is_a?(Class) || value.is_a?(String)
+
+        return @record_class = value
+      end
+
+      configured = @record_class
+      configured ||= superclass.record_class unless self == Model
+      configured.is_a?(String) ? configured.constantize : configured
+    end
 
     def initialize
       @builder = QueryBuilder.new(self.class)
@@ -23,77 +42,6 @@ module Noiseless
       end
     end
 
-    # Instance methods that delegate to the query builder
-    def match(field, value, **)
-      @builder.match(field, value, **)
-      self
-    end
-
-    def multi_match(query, fields, **)
-      @builder.multi_match(query, fields, **)
-      self
-    end
-
-    def filter(field, value, **)
-      @builder.filter(field, value, **)
-      self
-    end
-
-    def range(field, gte: nil, lte: nil, gt: nil, lt: nil)
-      @builder.range(field, gte: gte, lte: lte, gt: gt, lt: lt)
-      self
-    end
-
-    def sort(field, direction = :asc, **)
-      @builder.sort(field, direction, **)
-      self
-    end
-
-    def limit(size)
-      @builder.limit(size)
-      self
-    end
-
-    def offset(from)
-      @builder.offset(from)
-      self
-    end
-
-    def paginate(page: nil, per_page: nil)
-      @builder.paginate(page: page, per_page: per_page)
-      self
-    end
-
-    def aggregation(name, type, **)
-      @builder.aggregation(name, type, **)
-      self
-    end
-
-    def geo_distance(field, lat:, lon:, distance:, **)
-      @builder.geo_distance(field, lat: lat, lon: lon, distance: distance, **)
-      self
-    end
-
-    def indexes(names)
-      @builder.indexes(names)
-      self
-    end
-
-    def remove_duplicates(value: true)
-      @builder.remove_duplicates(value: value)
-      self
-    end
-
-    def facet_sample_slope(value)
-      @builder.facet_sample_slope(value)
-      self
-    end
-
-    def pinned_hits(value)
-      @builder.pinned_hits(value)
-      self
-    end
-
     def execute(connection: nil, response_type: nil)
       client = Noiseless.connections.client(connection || self.class.connection)
       ast = @builder.to_ast

data/lib/noiseless/model_registry.rb

@@ -17,7 +17,7 @@ module Noiseless
       }
 
       # Index models by their search index names
-      index_names = Array(model_class.search_index || default_index_name(model_class))
+      index_names = QueryBuilder.indexes_for(model_class)
       index_names.each do |index_name|
         @models_by_index[index_name.to_sym] ||= []
         @models_by_index[index_name.to_sym] << model_class
@@ -67,11 +67,5 @@ module Noiseless
       @models.clear
       @models_by_index.clear
     end
-
-    private
-
-    def default_index_name(model_class)
-      model_class.name.demodulize.underscore.pluralize
-    end
   end
 end

data/lib/noiseless/multi_search.rb

@@ -2,72 +2,28 @@
 
 module Noiseless
   class MultiSearch
+    extend QueryDelegation
+
+    delegate_query_methods :match, :multi_match, :filter, :sort, :limit, :offset, :aggregation,
+                           :geo_distance, :remove_duplicates, :facet_sample_slope, :pinned_hits,
+                           to: :@builder
+
     def initialize(models: nil, indexes: nil, connection: nil)
       @models = resolve_models(models)
       @indexes = resolve_indexes(indexes)
       @connection = connection || Noiseless.config.default_connection
-      @builder = QueryBuilder.new(nil)
+      @builder = QueryBuilder.new(nil).indexes(@indexes)
     end
 
     def search(&block)
       yield(@builder) if block
 
       client = Noiseless.connections.client(@connection)
-      ast = @builder.to_ast
-
-      # Override indexes in AST with our multi-model indexes
-      ast_with_indexes = AST::Root.new(
-        indexes: @indexes,
-        bool: ast.bool,
-        sort: ast.sort,
-        paginate: ast.paginate,
-        vector: ast.vector,
-        collapse: ast.collapse,
-        search_after: ast.search_after,
-        aggregations: ast.aggregations,
-        hybrid: ast.hybrid,
-        pipeline: ast.pipeline,
-        image_query: ast.image_query,
-        conversation: ast.conversation,
-        joins: ast.joins,
-        remove_duplicates: ast.remove_duplicates,
-        facet_sample_slope: ast.facet_sample_slope,
-        pinned_hits: ast.pinned_hits
-      )
-
-      raw_response = client.search(ast_with_indexes)
-      MultiSearchResponse.new(raw_response, @models, @indexes)
-    end
-
-    # Delegate query building methods to the internal builder
-    def match(field, value, **)
-      @builder.match(field, value, **)
-      self
-    end
-
-    def multi_match(query, fields, **)
-      @builder.multi_match(query, fields, **)
-      self
-    end
-
-    def filter(field, value, **)
-      @builder.filter(field, value, **)
-      self
-    end
-
-    def sort(field, direction = :asc, **)
-      @builder.sort(field, direction, **)
-      self
-    end
-
-    def limit(size)
-      @builder.limit(size)
-      self
-    end
-
-    def offset(from)
-      @builder.offset(from)
-      self
+      ast = @builder.indexes(@indexes).to_ast
+      response = Sync { client.search(ast, response_type: :results).wait }
+      MultiSearchResponse.new(response.response, @models, @indexes).tap do |result|
+        result.include_pagination_info(Pagination.query_options(ast.paginate))
+      end
     end
 
     def paginate(page, per_page)
@@ -75,31 +31,6 @@ module Noiseless
       self
     end
 
-    def aggregation(name, type, **)
-      @builder.aggregation(name, type, **)
-      self
-    end
-
-    def geo_distance(field, lat:, lon:, distance:, **)
-      @builder.geo_distance(field, lat: lat, lon: lon, distance: distance, **)
-      self
-    end
-
-    def remove_duplicates(value: true)
-      @builder.remove_duplicates(value: value)
-      self
-    end
-
-    def facet_sample_slope(value)
-      @builder.facet_sample_slope(value)
-      self
-    end
-
-    def pinned_hits(value)
-      @builder.pinned_hits(value)
-      self
-    end
-
     private
 
     def resolve_models(models)
@@ -125,9 +56,7 @@ module Noiseless
     def resolve_indexes(indexes)
       case indexes
       when nil
-        @models.flat_map do |model|
-          Array(model.search_index || default_index_name(model))
-        end.uniq
+        @models.flat_map { |model| QueryBuilder.indexes_for(model) }.uniq
       when Array
         indexes.map(&:to_s)
       when String, Symbol
@@ -136,10 +65,6 @@ module Noiseless
         []
       end
     end
-
-    def default_index_name(model_class)
-      model_class.name.demodulize.underscore.pluralize
-    end
   end
 
   # Multi-search response class
@@ -149,6 +74,10 @@ module Noiseless
       @models = models
       @indexes = indexes
       @results_by_model = nil
+      @models_by_index = {}
+      models.each do |model|
+        QueryBuilder.indexes_for(model).each { |index| @models_by_index[index] ||= model }
+      end
     end
 
     def each(&)
@@ -203,17 +132,8 @@ module Noiseless
     end
 
     def determine_model_class(hit)
-      index_name = hit["_index"]
-
-      # First, try to find models registered for this specific index
-      models_for_index = Noiseless.registry.models_for_index(index_name)
-      return models_for_index.first if models_for_index.size == 1
-
-      # If multiple models or none found, try to infer from index name
-      @models.find do |model|
-        model_indexes = Array(model.search_index || default_index_name(model))
-        model_indexes.include?(index_name)
-      end
+      # Only group into requested models, using the same index rules as search.
+      @models_by_index[hit["_index"]]
     end
 
     def load_records_by_model
@@ -221,24 +141,14 @@ module Noiseless
 
       results_by_model.each do |model_key, model_hits|
         model_class = @models.find { |m| m.name.to_sym == model_key }
-        next unless model_class.respond_to?(:where)
-
-        ids = model_hits.map { |hit| hit["_id"] }
-        loaded_records = model_class.where(id: ids).to_a
-
-        # Sort by search relevance
-        sorted_records = model_hits.filter_map do |hit|
-          loaded_records.find { |record| record.id.to_s == hit["_id"].to_s }
-        end
+        record_class = RecordClassResolver.resolve(model_class)
+        next unless record_class.respond_to?(:where)
 
-        records[model_key] = sorted_records
+        raw = { "hits" => { "hits" => model_hits, "total" => model_hits.size } }
+        records[model_key] = Response::Records.new(raw, record_class).to_a
       end
 
       records
     end
-
-    def default_index_name(model_class)
-      model_class.name.demodulize.underscore.pluralize
-    end
   end
 end