lookout-ahoy 0.1.0

data/lib/lookout/active_record.rb

@@ -0,0 +1,108 @@
+module ActiveRecord
+  module Querying
+    delegate :with, to: :all
+  end
+
+  module WithMerger
+    def merge
+      super
+      merge_withs
+      relation
+    end
+
+    private
+
+    def merge_withs
+      relation.recursive_with = true if other.recursive_with?
+      other_values = other.with_values.reject { |value| relation.with_values.include?(value) }
+      relation.with!(*other_values) if other_values.any?
+    end
+  end
+
+  class Relation
+    class Merger
+      prepend WithMerger
+    end
+
+    def with(opts, *rest)
+      spawn.with!(opts, *rest)
+    end
+
+    def with!(opts, *rest)
+      if opts == :recursive
+        self.recursive_with = true
+        self.with_values += rest
+      else
+        self.with_values += [opts] + rest
+      end
+      self
+    end
+
+    def with_values
+      @values[:with] || []
+    end
+
+    def with_values=(values)
+      raise ImmutableRelation if @loaded
+
+      @values[:with] = values
+    end
+
+    def recursive_with?
+      @values[:recursive_with]
+    end
+
+    def recursive_with=(value)
+      raise ImmutableRelation if @loaded
+
+      @values[:recursive_with] = value
+    end
+
+    private
+
+    def build_arel(*args)
+      arel = super
+      build_with(arel) if @values[:with]
+      arel
+    end
+
+    def build_with(arel) # rubocop:disable Metrics/MethodLength, Metrics/CyclomaticComplexity
+      return if with_values.empty?
+
+      with_statements = with_values.map do |with_value|
+        case with_value
+        when String then Arel::Nodes::SqlLiteral.new(with_value)
+        when Arel::Nodes::As then with_value
+        when Hash then build_with_value_from_hash(with_value)
+        when Array then build_with_value_from_array(with_value)
+        else
+          raise ArgumentError, "Unsupported argument type: #{with_value} #{with_value.class}"
+        end
+      end
+
+      recursive_with? ? arel.with(:recursive, with_statements) : arel.with(with_statements)
+    end
+
+    def build_with_value_from_array(array)
+      unless array.map(&:class).uniq == [Arel::Nodes::As]
+        raise ArgumentError, "Unsupported argument type: #{array} #{array.class}"
+      end
+
+      array
+    end
+
+    def build_with_value_from_hash(hash) # rubocop:disable Metrics/MethodLength
+      hash.map do |name, value|
+        table = Arel::Table.new(name)
+        expression = case value
+                     when String then Arel::Nodes::SqlLiteral.new("(#{value})")
+                     when ActiveRecord::Relation then value.arel
+                     when Arel::SelectManager, Arel::Nodes::Union then value
+                     else
+                       raise ArgumentError, "Unsupported argument type: #{value} #{value.class}"
+                     end
+        Arel::Nodes::As.new(table, expression)
+      end
+    end
+  end
+end

data/lib/lookout/ahoy/event_methods.rb

@@ -0,0 +1,75 @@
+module Lookout
+  module Ahoy
+    module EventMethods
+      extend ActiveSupport::Concern
+
+      included do
+        scope :page_view, -> { where("name = '#{Lookout.config.event[:view_name]}'") }
+
+        ransacker :route do |_parent|
+          Arel.sql(Lookout.config.event[:url_column])
+        end
+
+        ransacker :entry_page do |parent|
+          Arel.sql("entry_pages.url")
+        end
+
+        ransacker :exit_page do |parent|
+          Arel.sql("exit_pages.url")
+        end
+
+        scope :with_entry_pages, -> {
+          with(entry_pages: self.select("MIN(#{table_name}.id) as min_id, #{Arel.sql("#{Lookout.config.event.url_column} AS url")}").where(name: Lookout.config.event[:view_name]).group("#{table_name}.properties")).joins("INNER JOIN entry_pages ON entry_pages.min_id = #{table_name}.id")
+        }
+
+        scope :with_exit_pages, -> {
+          with(exit_pages: self.select("MAX(#{table_name}.id) as max_id, #{Arel.sql("#{Lookout.config.event.url_column} AS url")}")
+                               .where(name: Lookout.config.event[:view_name]).group("#{table_name}.properties"))
+            .joins("INNER JOIN exit_pages ON exit_pages.max_id = #{table_name}.id")
+        }
+
+        scope :with_routes, -> { where(Lookout.config.event[:url_exists]) }
+
+        scope :with_url, -> {
+          select(Arel.sql("#{Lookout.config.event.url_column} AS url"))
+        }
+
+        scope :distinct_url, -> {
+          distinct(Arel.sql("#{Lookout.config.event.url_column}"))
+        }
+
+        scope :with_property_values, ->(value) {
+          where(Lookout::DatabaseAdapter.json_key_exists("properties", value))
+        }
+
+        ransacker :properties, args: [:parent, :ransacker_args] do |parent, args|
+          Lookout::DatabaseAdapter.ransacker_json_extract(parent, args)
+        end
+
+        ransacker :goal,
+                  formatter: ->(value) {
+                    ::Arel::Nodes::SqlLiteral.new(
+                      ::Lookout.config.goals[value].event_query.call.select(:id).to_sql
+                    )
+                  } do |parent|
+          parent.table[:id]
+        end
+      end
+
+      class_methods do
+        def ransackable_attributes(auth_object = nil)
+          super + [ "action", "controller", "id",  "name", "page", "properties", "time", "url", "user_id", "visit_id", "goal"] + self._ransackers.keys
+        end
+
+        def ransackable_scopes(auth_object = nil)
+          super + [:with_property_values, :property_value_i_cont]
+        end
+
+        def ransackable_associations(auth_object = nil)
+          super + [:visit]
+        end
+      end
+    end
+  end
+end
+

data/lib/lookout/ahoy/visit_methods.rb

@@ -0,0 +1,24 @@
+module Lookout
+  module Ahoy
+    module VisitMethods
+      extend ActiveSupport::Concern
+
+      included do
+        ransacker :ref_domain do
+          expr = Lookout::DatabaseAdapter.domain_from("#{self.table_name}.referring_domain")
+          Arel.sql("(#{expr})")
+        end
+      end
+
+      class_methods do
+        def ransackable_attributes(auth = nil)
+          columns_hash.keys + ["ref_domain"]
+        end
+
+        def ransackable_associations(auth = nil)
+          super + ["events"]
+        end
+      end
+    end
+  end
+end

data/lib/lookout/configuration.rb

@@ -0,0 +1,58 @@
+require 'lookout/period_collection'
+require 'lookout/filters_configuration'
+
+module Lookout
+  class Configuration
+    attr_accessor :view_name, :theme, :realtime_interval, :disabled_widgets, :return_path, :return_copy
+    attr_reader :goals, :funnels, :cache, :ranges, :event, :models, :filters, :predicate_labels
+    def initialize
+      @goals = GoalCollection.new
+      @funnels = FunnelCollection.new
+      @theme = "dark"
+      @return_path = "/"
+      @return_copy = "← Back"
+      @ranges = ::Lookout::PeriodCollection.load_default
+      @cache = ActiveSupport::OrderedOptions.new.tap do |option|
+        option.enabled = false
+        option.store = Rails.cache
+        option.ttl = 1.minute
+      end
+      @models = ActiveSupport::OrderedOptions.new.tap do |option|
+        option.event = "::Ahoy::Event"
+        option.visit = "::Ahoy::Visit"
+      end
+      @event = ActiveSupport::OrderedOptions.new.tap do |option|
+        option.view_name = "$view"
+        # Dynamically generate SQL based on database adapter
+        table_name = @models.event.parameterize.tableize
+        option.url_column = DatabaseAdapter.build_url_column(table_name)
+        option.url_exists = DatabaseAdapter.build_url_exists(table_name)
+      end
+      @filters = FiltersConfiguration.load_default
+      @predicate_labels = {
+        eq: 'equals',
+        not_eq: 'not equals',
+        cont: 'contains',
+        in: 'in',
+        not_in: 'not in',
+      }
+
+      @realtime_interval = 30.seconds
+      @disabled_widgets = []
+    end
+
+    def goal(id, &block)
+      instance = Goal.new
+      instance.id = id
+      instance.instance_exec(&block)
+      @goals.register(instance)
+    end
+
+    def funnel(id, &block)
+      instance = Funnel.new
+      instance.id = id
+      instance.instance_exec(&block)
+      @funnels.register(instance)
+    end
+  end
+end

data/lib/lookout/database_adapter.rb

@@ -0,0 +1,168 @@
+module Lookout
+  module DatabaseAdapter
+    class << self
+      # Detect the database adapter being used
+      def adapter_name
+        @adapter_name ||= detect_adapter
+      end
+
+      # Reset cached adapter name (useful for testing)
+      def reset!
+        @adapter_name = nil
+      end
+
+      def postgresql?
+        adapter_name == :postgresql
+      end
+
+      def sqlite?
+        adapter_name == :sqlite
+      end
+
+      # Generate SQL for concatenating strings
+      def concat(*args)
+        if postgresql?
+          "CONCAT(#{args.join(', ')})"
+        else # sqlite
+          args.join(' || ')
+        end
+      end
+
+      # Generate SQL for extracting JSON text value
+      # Usage: json_extract_text('properties', 'controller')
+      def json_extract_text(column, key)
+        if postgresql?
+          "#{column}->>'#{key}'"
+        else # sqlite
+          "JSON_EXTRACT(#{column}, '$.#{key}')"
+        end
+      end
+
+      # Generate SQL for checking if JSON key exists
+      def json_key_exists(column, key)
+        if postgresql?
+          "JSONB_EXISTS(#{column}, '#{key}')"
+        else # sqlite
+          "JSON_TYPE(#{column}, '$.#{key}') IS NOT NULL"
+        end
+      end
+
+      # Generate SQL for getting all JSON object keys
+      # Returns a query that produces rows with a 'keys' column
+      def json_object_keys(column)
+        if postgresql?
+          "jsonb_object_keys(#{column})"
+        else # sqlite
+          # SQLite doesn't have a built-in function for this
+          # We'll need to use json_each which returns key/value pairs
+          # This will be used in a subquery context
+          "json_each.key"
+        end
+      end
+
+      # Generate the FROM clause for getting JSON keys
+      # For SQLite, we need to use json_each()
+      def json_keys_from_clause(table_name, column)
+        if postgresql?
+          table_name
+        else # sqlite
+          "#{table_name}, json_each(#{table_name}.#{column})"
+        end
+      end
+
+      # Generate SQL for JSON contains check (for ransacker)
+      def json_infix_operator
+        if postgresql?
+          '->>'
+        else # sqlite
+          # We'll handle this differently in SQLite
+          # Return a marker that we can detect and handle specially
+          'JSON_EXTRACT'
+        end
+      end
+
+      # Generate SQL for building URL from controller/action in properties
+      # table_name: the table name (e.g., 'ahoy_events')
+      def build_url_column(table_name)
+        controller = json_extract_text("#{table_name}.properties", 'controller')
+        action = json_extract_text("#{table_name}.properties", 'action')
+        
+        if postgresql?
+          "CONCAT(#{controller}, '#', #{action})"
+        else # sqlite
+          "#{controller} || '#' || #{action}"
+        end
+      end
+
+      # Generate SQL for checking if URL properties exist
+      def build_url_exists(table_name)
+        controller_exists = json_key_exists("#{table_name}.properties", 'controller')
+        action_exists = json_key_exists("#{table_name}.properties", 'action')
+        
+        "#{controller_exists} AND #{action_exists}"
+      end
+
+      # For SQLite JSON_EXTRACT in ransacker, we need special handling
+      def ransacker_json_extract(parent, key)
+        if postgresql?
+          Arel::Nodes::InfixOperation.new('->>', parent.table[:properties], Arel::Nodes.build_quoted(key))
+        else # sqlite
+          Arel::Nodes::NamedFunction.new(
+            'JSON_EXTRACT',
+            [parent.table[:properties], Arel::Nodes.build_quoted("$.#{key}")]
+          )
+        end
+      end
+
+      # Extract domain from a referrer/URL column
+      # column can be a bare column (referring_domain) or qualified (table.referring_domain)
+      def domain_from(column)
+        if postgresql?
+          # Use regex form supported by Postgres
+          "substring(#{column} from '(?:.*://)?(?:www\\.)?([^/?]*)')"
+        else
+          # SQLite: derive domain using instr/substr
+          # Step 1: strip scheme
+          base = "CASE WHEN instr(#{column}, '://') > 0 THEN substr(#{column}, instr(#{column}, '://') + 3) ELSE #{column} END"
+          # Step 2: strip leading www.
+          no_www = "CASE WHEN substr(#{base}, 1, 4) = 'www.' THEN substr(#{base}, 5) ELSE #{base} END"
+          # Step 3: take up to first '/'
+          "CASE WHEN instr(#{no_www}, '/') > 0 THEN substr(#{no_www}, 1, instr(#{no_www}, '/') - 1) ELSE #{no_www} END"
+        end
+      end
+
+      # Cast a number to decimal/real for percentage calculations
+      def numeric_cast(expression)
+        if postgresql?
+          "#{expression}::numeric"
+        else # sqlite
+          "CAST(#{expression} AS REAL)"
+        end
+      end
+
+      # Calculate percentage: (numerator / denominator) * 100
+      def percentage_calculation(numerator, denominator)
+        if postgresql?
+          "(#{numerator}/#{denominator}::numeric) * 100"
+        else # sqlite
+          "(CAST(#{numerator} AS REAL) / #{denominator}) * 100"
+        end
+      end
+
+      private
+
+      def detect_adapter
+        name = ActiveRecord::Base.connection_db_config.adapter.to_s
+        case name
+        when /postg/i
+          :postgresql
+        when /sqlite/i
+          :sqlite
+        else
+          raise "Unsupported database adapter: #{name}. Lookout supports PostgreSQL and SQLite only."
+        end
+      end
+    end
+  end
+end
+

data/lib/lookout/engine.rb

@@ -0,0 +1,47 @@
+require 'ahoy'
+require 'turbo-rails'
+require 'stimulus-rails'
+require 'ransack'
+require 'view_component'
+require 'groupdate'
+require 'pagy'
+require 'zip'
+
+module Ransack
+  module Nodes
+    class Condition
+
+      # allows for sql from a formatter
+      # see https://github.com/activerecord-hackery/ransack/issues/702
+      def casted_array?(predicate)
+        return unless predicate.is_a?(Arel::Nodes::Casted)
+
+        predicate.value.is_a?(Array)
+      end
+
+    end
+  end
+end
+
+Ransack.configure do |config|
+  config.add_predicate 'json_cont', arel_predicate: 'contains', formatter: proc { |v| JSON.parse(v) }
+  config.add_predicate 'json_eq', arel_predicate: 'eq', formatter: proc { |v| JSON.parse(v) }
+end
+
+module Lookout
+  class Engine < Rails::Engine
+    isolate_namespace ::Lookout
+
+    initializer "lookout.precompile" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << Lookout::Engine.root.join("app/javascript")
+        app.config.assets.paths << Lookout::Engine.root.join("app/images")
+        app.config.assets.precompile << "lookout/application.js"
+      end
+    end
+
+    ActiveSupport.on_load(:active_record) do
+      require "lookout/active_record"
+    end
+  end
+end

data/lib/lookout/filter_configuration/filter.rb

@@ -0,0 +1,16 @@
+module Lookout
+  class FilterConfiguration
+    class Filter
+      attr_reader :column, :label, :url, :predicates, :multiple, :position
+
+      def initialize(label:, column:, url:, predicates: [:in, :not_in], multiple: true, position: nil)
+        @column = column
+        @label = label
+        @url = url
+        @predicates = predicates
+        @multiple = multiple
+        @position = position
+      end
+    end
+  end
+end

data/lib/lookout/filter_configuration/filter_collection.rb

@@ -0,0 +1,48 @@
+module Lookout
+  class FilterConfiguration
+    class FilterCollection
+      def initialize(label)
+        @label = label
+        @registry = []
+      end
+
+      def filter(label:, column:, url:, predicates: [:in, :not_in], multiple: true, position: nil)
+        position ||= @registry.size
+        if item = find(column)
+          @registry.delete(item)
+        end
+
+        @registry << FilterConfiguration::Filter.new(label: label, column: column, url: url, predicates: predicates, multiple: multiple, position: position)
+        @registry = @registry.sort_by { |filter| filter.position }
+      end
+
+      def each(&block)
+        @registry.each(&block)
+      end
+
+      def modal_name
+        "#{@label.parameterize.underscore}Modal"
+      end
+
+      def find(column)
+        @registry.find { |filter| filter.column == column.to_sym }
+      end
+
+      def delete(name)
+        @registry.delete_if { |filter| filter.column == name }
+      end
+
+      def filters
+        @registry
+      end
+
+      def [](name)
+        find(name)
+      end
+
+      def include?(name)
+        find(name).present?
+      end
+    end
+  end
+end

data/lib/lookout/filters_configuration.rb

@@ -0,0 +1,77 @@
+require 'lookout/filter_configuration/filter'
+require 'lookout/filter_configuration/filter_collection'
+
+module Lookout
+  class FiltersConfiguration
+    def self.load_default
+      new.tap do |config|
+        config.register("Page") do
+          filter column: :route, label: "Route", url: :filters_actions_path, predicates: [:in, :not_in]
+          filter column: :entry_page, label: "Entry Page", url: :filters_entry_pages_path, predicates: [:in, :not_in]
+          filter column: :exit_page, label: "Exit Page", url: :filters_exit_pages_path, predicates: [:in, :not_in]
+        end
+
+        config.register("Geography") do
+          filter column: :country, label: "Country", url: :filters_locations_countries_path, predicates: [:in, :not_in]
+          filter column: :region, label: "Region", url: :filters_locations_regions_path, predicates: [:in, :not_in]
+          filter column: :city, label: "City", url: :filters_locations_cities_path, predicates: [:in, :not_in]
+        end
+
+        config.register("Source") do
+          filter column: :referring_domain, label: "Source", url: :filters_sources_path, predicates: [:in, :not_in]
+        end
+
+        config.register("Screen size") do
+          filter column: :device_type, label: "Screen size", url: :filters_screens_path, predicates: [:in, :not_in]
+        end
+
+        config.register("Operating System") do
+          filter column: :os, label: "OS Name", url: :filters_names_path, predicates: [:in, :not_in]
+          filter column: :os_version, label: "OS Version", url: :filters_versions_path, predicates: [:in, :not_in]
+        end
+
+        config.register("UTM Tags") do
+          filter column: :utm_medium, label: "UTM Medium", url: :filters_utm_mediums_path, predicates: [:in, :not_in, :cont]
+          filter column: :utm_source, label: "UTM Source", url: :filters_utm_sources_path, predicates: [:in, :not_in, :cont]
+          filter column: :utm_campaign, label: "UTM Campaign", url: :filters_utm_campaigns_path, predicates: [:in, :not_in, :cont]
+          filter column: :utm_term, label: "UTM Term", url: :filters_utm_terms_path, predicates: [:in, :not_in, :cont]
+          filter column: :utm_content, label: "UTM Content", url: :filters_utm_contents_path, predicates: [:in, :not_in, :cont]
+        end
+
+        config.register("Goal") do
+          filter column: :goal, label: "Goal", url: :filters_goals_path, predicates: [:in]
+        end
+      end
+    end
+
+    def initialize
+      @registry = {}
+    end
+
+    def register(label, &block)
+      item = FilterConfiguration::FilterCollection.new(label)
+      item.instance_exec(&block)
+      @registry[label] = item
+    end
+
+    def [](val)
+      @registry[val]
+    end
+
+    def delete(name)
+      @registry.delete(name)
+    end
+
+    def reset
+      @registry = {}
+    end
+
+    def each(&block)
+      @registry.each(&block)
+    end
+
+    def detect(&block)
+      @registry.detect(&block)
+    end
+  end
+end

data/lib/lookout/funnels.rb

@@ -0,0 +1,44 @@
+module Lookout
+  class Funnel
+    attr_accessor :id
+    attr_reader :goals
+
+    def initialize
+      @id = nil
+      @label = nil
+      @goals = []
+    end
+
+    def goal(id)
+      @goals << Lookout.config.goals[id]
+    end
+
+    def label(value)
+      @label = value
+    end
+
+    def title
+      @label
+    end
+  end
+
+  class FunnelCollection
+    include Enumerable
+
+    def initialize
+      @funnels = {}
+    end
+
+    def register(funnel)
+      @funnels[funnel.id] = funnel
+    end
+
+    def each(&block)
+      @funnels.each(&block)
+    end
+
+    def [](value)
+      @funnels[value.to_sym]
+    end
+  end
+end