noiseless 0.0.0 → 0.1.0

data/lib/noiseless/response/aggregations.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module Response
+    class Aggregations
+      include Enumerable
+
+      def initialize(aggs_hash)
+        @aggs_hash = aggs_hash || {}
+      end
+
+      def [](key)
+        @aggs_hash[key.to_s]
+      end
+
+      delegate :keys, to: :@aggs_hash
+
+      def each(&)
+        return enum_for(__method__) unless block_given?
+
+        @aggs_hash.each(&)
+      end
+
+      delegate :empty?, to: :@aggs_hash
+
+      delegate :size, to: :@aggs_hash
+
+      def to_h
+        @aggs_hash
+      end
+
+      # Handle method conflicts with Enumerable methods
+      def method_missing(method_name, *args, &)
+        if @aggs_hash.key?(method_name.to_s)
+          @aggs_hash[method_name.to_s]
+        else
+          super
+        end
+      end
+
+      def respond_to_missing?(method_name, include_private = false)
+        @aggs_hash.key?(method_name.to_s) || super
+      end
+    end
+  end
+end

data/lib/noiseless/response/empty.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module Response
+    class Empty < Base
+      EMPTY_RESPONSE = {
+        "hits" => { "total" => { "value" => 0 }, "hits" => [] },
+        "took" => 0
+      }.freeze
+
+      def initialize(model_class = nil)
+        super(EMPTY_RESPONSE, model_class)
+      end
+
+      def each
+        return enum_for(__method__) unless block_given?
+      end
+    end
+  end
+end

data/lib/noiseless/response/records.rb

@@ -0,0 +1,94 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module Response
+    class Records < Base
+      def initialize(raw_response, model_class)
+        super
+        @records = nil
+        @record_hit_map = nil
+      end
+
+      def each(&)
+        return enum_for(__method__) unless block_given?
+
+        records.each(&)
+      end
+
+      def each_with_hit
+        return enum_for(__method__) unless block_given?
+
+        records.each_with_index do |record, index|
+          hit = hits[record_hit_map[record] || index]
+          yield(record, hit)
+        end
+      end
+
+      def map_with_hit(&)
+        return enum_for(__method__) unless block_given?
+
+        each_with_hit.map(&)
+      end
+
+      def records
+        @records ||= load_records_with_pagination
+      end
+
+      delegate :first, to: :records
+
+      delegate :last, to: :records
+
+      delegate :[], to: :records
+
+      def to_a
+        records
+      end
+
+      private
+
+      def load_records_with_pagination
+        records = load_records
+
+        # Wrap in PaginatedArray for pagination metadata
+        current_page = @from && @per_page ? (@from / @per_page) + 1 : 1
+        per_page = @per_page || Pagination::DEFAULT_PER_PAGE
+
+        Pagination::PaginatedArray.new(
+          records,
+          current_page: current_page,
+          per_page: per_page,
+          total_count: total
+        )
+      end
+
+      def load_records
+        return [] if hits.empty? || !model_class.respond_to?(:where)
+
+        # Extract IDs from hits
+        ids = hits.map { |hit| hit["_id"] }
+
+        # Load records from database
+        loaded_records = model_class.where(id: ids).to_a
+
+        # Create mapping from record to hit index for correlation
+        @record_hit_map = {}
+
+        # Sort records by the order they appear in search results
+        sorted_records = []
+        hits.each_with_index do |hit, hit_index|
+          record = loaded_records.find { |r| r.id.to_s == hit["_id"].to_s }
+          if record
+            sorted_records << record
+            @record_hit_map[record] = hit_index
+          end
+        end
+
+        sorted_records
+      end
+
+      def record_hit_map
+        @record_hit_map ||= {}
+      end
+    end
+  end
+end

data/lib/noiseless/response/results.rb

@@ -0,0 +1,110 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module Response
+    class Results < Base
+      def each
+        return enum_for(__method__) unless block_given?
+
+        hits.each do |hit|
+          yield Result.new(hit)
+        end
+      end
+
+      def sources
+        @sources ||= hits.map { |hit| hit["_source"] }
+      end
+
+      alias records sources
+
+      def each_source(&)
+        return enum_for(__method__) unless block_given?
+
+        sources.each(&)
+      end
+
+      def map_source(&)
+        return enum_for(__method__) unless block_given?
+
+        sources.map(&)
+      end
+
+      def first
+        hit = hits.first
+        hit ? Result.new(hit) : nil
+      end
+
+      def last
+        hit = hits.last
+        hit ? Result.new(hit) : nil
+      end
+
+      def [](index)
+        hit = hits[index]
+        hit ? Result.new(hit) : nil
+      end
+
+      def to_a
+        hits.map { |hit| Result.new(hit) }
+      end
+
+      def map
+        return enum_for(__method__) unless block_given?
+
+        results = []
+        each do |result|
+          results << yield(result)
+        end
+        results
+      end
+
+      def select
+        return enum_for(__method__) unless block_given?
+
+        results = []
+        each do |result|
+          results << result if yield(result)
+        end
+        results
+      end
+
+      def ids
+        @ids ||= hits.map { |hit| hit["_id"] }
+      end
+
+      def scores
+        @scores ||= hits.map { |hit| hit["_score"] }
+      end
+
+      # Make results enumerable with source property
+      def find
+        return enum_for(__method__) unless block_given?
+
+        hits.each do |hit|
+          result = Result.new(hit)
+          return result if yield(result)
+        end
+        nil
+      end
+
+      class Result
+        attr_reader :source
+
+        def initialize(hit)
+          @hit = hit
+          @source = hit["_source"]
+        end
+
+        def id
+          @hit["_id"]
+        end
+
+        def score
+          @hit["_score"]
+        end
+
+        delegate :[], to: :@source
+      end
+    end
+  end
+end

data/lib/noiseless/response/suggestions.rb

@@ -0,0 +1,55 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module Response
+    class Suggestions
+      include Enumerable
+
+      def initialize(suggestions_hash)
+        @suggestions_hash = suggestions_hash || {}
+      end
+
+      def [](key)
+        @suggestions_hash[key.to_s]
+      end
+
+      delegate :keys, to: :@suggestions_hash
+
+      def each(&)
+        return enum_for(__method__) unless block_given?
+
+        @suggestions_hash.each(&)
+      end
+
+      delegate :empty?, to: :@suggestions_hash
+
+      delegate :size, to: :@suggestions_hash
+
+      def to_h
+        @suggestions_hash
+      end
+
+      def terms
+        @terms ||= extract_terms
+      end
+
+      private
+
+      def extract_terms
+        terms = []
+        @suggestions_hash.each_value do |suggestion|
+          next unless suggestion.is_a?(Array)
+
+          suggestion.each do |item|
+            next unless item.is_a?(Hash) && item["options"]
+
+            item["options"].each do |option|
+              terms << option["text"] if option["text"]
+            end
+          end
+        end
+        terms.uniq
+      end
+    end
+  end
+end

data/lib/noiseless/response.rb

@@ -0,0 +1,98 @@
+# frozen_string_literal: true
+
+module Noiseless
+  module Response
+    class Base
+      include Enumerable
+      include Pagination::ResponsePagination
+
+      def initialize(raw_response, model_class = nil)
+        @raw_response = raw_response
+        @model_class = model_class
+      end
+
+      def total
+        case @raw_response.dig("hits", "total")
+        when Hash
+          @raw_response.dig("hits", "total", "value") || 0
+        when Integer
+          @raw_response.dig("hits", "total") || 0
+        else
+          0
+        end
+      end
+
+      def hits
+        @hits ||= @raw_response.dig("hits", "hits") || []
+      end
+
+      def took
+        @raw_response["took"]
+      end
+
+      def aggregations
+        @aggregations ||= Aggregations.new(@raw_response["aggregations"] || {})
+      end
+
+      def suggestions
+        @suggestions ||= Suggestions.new(@raw_response["suggest"] || {})
+      end
+
+      def each(&)
+        raise NotImplementedError, "Subclasses must implement #each"
+      end
+
+      def empty?
+        total.zero?
+      end
+
+      delegate :size, to: :hits
+
+      def length
+        size
+      end
+
+      def include_pagination_info(query_hash)
+        @from = query_hash[:from] || 0
+        @per_page = query_hash[:size] || 20
+      end
+
+      # Compatibility methods for CommonShare
+      def response
+        @raw_response
+      end
+
+      def result
+        # Alias for results - controllers expect .result
+        results
+      end
+
+      def results
+        # For Results class, return self. For Records, return a Results view
+        if is_a?(Results)
+          self
+        else
+          Results.new(@raw_response, @model_class)
+        end
+      end
+
+      def count
+        size
+      end
+
+      def total_count
+        total
+      end
+
+      def each_with_index(&)
+        return enum_for(__method__) unless block_given?
+
+        each.with_index(&)
+      end
+
+      private
+
+      attr_reader :raw_response, :model_class
+    end
+  end
+end

data/lib/noiseless/response_factory.rb

@@ -0,0 +1,32 @@
+# frozen_string_literal: true
+
+module Noiseless
+  class ResponseFactory
+    def self.create(raw_response, model_class: nil, response_type: nil, query_hash: nil)
+      # Auto-detect response type based on model class and preferences
+      response_type ||= detect_response_type(model_class)
+
+      response = case response_type
+                 when :records
+                   Response::Records.new(raw_response, model_class)
+                 else # :results or unknown
+                   Response::Results.new(raw_response, model_class)
+                 end
+
+      # Include pagination information if query hash is provided
+      response.include_pagination_info(query_hash) if query_hash
+
+      response
+    end
+
+    def self.detect_response_type(model_class)
+      # If model_class responds to ActiveRecord-like methods, default to :records
+      if model_class.respond_to?(:where) &&
+         model_class.respond_to?(:find)
+        :records
+      else
+        :results
+      end
+    end
+  end
+end

data/lib/noiseless/runtime_reset_middleware.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+module Noiseless
+  class RuntimeResetMiddleware
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      # Reset runtime tracking at the beginning of each request
+      Thread.current[:noiseless_runtime] = 0
+      @app.call(env)
+    end
+  end
+end

data/lib/noiseless/search_index_update_job.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+module Noiseless
+  class SearchIndexUpdateJob
+    def self.perform_later(model_class_name, record_id, operation, options = {})
+      if defined?(ActiveJob::Base)
+        ActiveJobSearchIndexUpdateJob.perform_later(model_class_name, record_id, operation, options)
+      elsif defined?(Sidekiq)
+        SidekiqSearchIndexUpdateJob.perform_async(model_class_name, record_id, operation, options)
+      else
+        # Fallback to immediate execution
+        perform_now(model_class_name, record_id, operation, options)
+      end
+    end
+
+    def self.perform_now(model_class_name, record_id, operation, options = {})
+      model_class = model_class_name.constantize
+
+      case operation
+      when "update"
+        record = model_class.find(record_id)
+        record.document_manager.update_document(**options)
+      when "delete"
+        # For delete operations, we need to construct a minimal object
+        # since the record might already be deleted from the database
+        document_manager = DocumentManager.new(
+          DeletedRecord.new(model_class, record_id)
+        )
+        document_manager.delete_document(**options)
+      else
+        raise ArgumentError, "Unknown operation: #{operation}"
+      end
+    rescue StandardError => e
+      if options[:raise_on_error]
+        raise e
+      elsif (logger = Rails.logger)
+        # Log error silently
+        logger.error "Noiseless: Background job failed for #{model_class_name}##{record_id}: #{e.message}"
+      end
+    end
+
+    # Minimal object for deleted records
+    class DeletedRecord
+      def initialize(model_class, record_id)
+        @model_class = model_class
+        @record_id = record_id
+      end
+
+      def id
+        @record_id
+      end
+
+      def class
+        @model_class
+      end
+
+      def to_search_document
+        nil
+      end
+    end
+  end
+
+  # ActiveJob integration
+  if defined?(ActiveJob::Base)
+    class ActiveJobSearchIndexUpdateJob < ActiveJob::Base
+      queue_as :default
+
+      def perform(model_class_name, record_id, operation, options = {})
+        SearchIndexUpdateJob.perform_now(model_class_name, record_id, operation, options)
+      end
+    end
+  end
+
+  # Sidekiq integration
+  if defined?(Sidekiq)
+    class SidekiqSearchIndexUpdateJob
+      include Sidekiq::Worker
+
+      def perform(model_class_name, record_id, operation, options = {})
+        SearchIndexUpdateJob.perform_now(model_class_name, record_id, operation, options)
+      end
+    end
+  end
+end