athar 0.2.1 → 0.3.0

data/lib/athar/dashboard/feed_query.rb

@@ -0,0 +1,222 @@
+# frozen_string_literal: true
+
+module Athar
+  module Dashboard
+    class FeedQuery # rubocop:disable Metrics/ClassLength
+      # Typed empty SELECT used for either UNION leg when the kind filter
+      # excludes that leg. Column types must match the live SELECTs above
+      # so PostgreSQL can compose the UNION without coercion.
+      DELETION_SEARCH_COLUMNS = %w[
+        record_type record_id::text schema_name table_name
+        actor_type actor_id::text record_data::text metadata::text
+      ].freeze
+
+      TABLE_EVENT_SEARCH_COLUMNS = %w[
+        schema_name table_name actor_type actor_id::text metadata::text
+      ].freeze
+
+      EMPTY_LEG_SELECT = <<~SQL
+        SELECT
+          NULL::text        AS kind,
+          NULL::bigint      AS id,
+          NULL::text        AS record_type,
+          NULL::text        AS record_id,
+          NULL::text        AS schema_name,
+          NULL::text        AS table_name,
+          NULL::text        AS actor_type,
+          NULL::text        AS actor_id,
+          NULL::timestamptz AS occurred_at,
+          NULL::jsonb       AS record_data,
+          NULL::jsonb       AS metadata
+        WHERE FALSE
+      SQL
+
+      def initialize(filters:, per_page: 25, now: Time.current, registry: nil)
+        @filters = filters
+        @per_page = per_page
+        @now = now
+        @registry = registry
+      end
+
+      def call(connection: ActiveRecord::Base.connection)
+        connection.select_all(page_sql, "FeedQuery#call").map { |row| to_row(row) }
+      end
+
+      def total(connection: ActiveRecord::Base.connection)
+        connection.select_value(count_sql, "FeedQuery#total").to_i
+      end
+
+      private
+
+      attr_reader :filters, :per_page, :now
+
+      def page_sql
+        <<~SQL
+          SELECT * FROM (
+            #{deletion_select}
+            UNION ALL
+            #{table_event_select}
+          ) feed
+          ORDER BY occurred_at DESC, id DESC
+          LIMIT #{per_page} OFFSET #{(filters.page - 1) * per_page}
+        SQL
+      end
+
+      def count_sql
+        "SELECT COUNT(*) FROM (#{deletion_select} UNION ALL #{table_event_select}) feed"
+      end
+
+      def deletion_select
+        return EMPTY_LEG_SELECT if filters.kind == "truncate"
+
+        <<~SQL
+          SELECT
+            'deletion'::text AS kind,
+            id,
+            record_type,
+            record_id::text AS record_id,
+            schema_name,
+            table_name,
+            actor_type,
+            actor_id::text AS actor_id,
+            deleted_at AS occurred_at,
+            record_data,
+            metadata
+          FROM #{Athar::DELETIONS_TABLE_NAME}
+          WHERE #{deletion_where_clause}
+        SQL
+      end
+
+      def table_event_select
+        return EMPTY_LEG_SELECT if filters.kind == "delete"
+
+        <<~SQL
+          SELECT
+            'truncate'::text AS kind,
+            id,
+            NULL::text AS record_type,
+            NULL::text AS record_id,
+            schema_name,
+            table_name,
+            actor_type,
+            actor_id::text AS actor_id,
+            occurred_at,
+            NULL::jsonb AS record_data,
+            metadata
+          FROM #{Athar::TABLE_EVENTS_TABLE_NAME}
+          WHERE event_type = 'truncate' AND #{table_event_where_clause}
+        SQL
+      end
+
+      def deletion_where_clause # rubocop:disable Metrics/AbcSize
+        clauses = ["TRUE"]
+        clauses << time_clause("deleted_at")
+        clauses << "record_type = #{quote(filters.model)}" if filters.model
+        # capture_mode is not on the audit row; mode filter operates by table.
+        clauses << tables_with_mode_clause(filters.mode) if filters.mode != "all"
+        clauses << actor_clause("athar_deletions")
+        clauses << search_clause(DELETION_SEARCH_COLUMNS)
+        clauses.compact.join(" AND ")
+      end
+
+      def table_event_where_clause # rubocop:disable Metrics/AbcSize
+        clauses = ["TRUE"]
+        clauses << time_clause("occurred_at")
+        clauses << tables_for_model_clause if filters.model
+        clauses << tables_with_mode_clause(filters.mode) if filters.mode != "all"
+        clauses << actor_clause("athar_table_events")
+        clauses << search_clause(TABLE_EVENT_SEARCH_COLUMNS)
+        clauses.compact.join(" AND ")
+      end
+
+      def time_clause(column)
+        cutoff = filters.time_cutoff(now)
+        return nil unless cutoff
+
+        "#{column} >= #{quote(cutoff)}"
+      end
+
+      def actor_clause(_table)
+        actor_filter = filters.actor_filter
+        return nil unless actor_filter
+
+        case actor_filter[:kind]
+        when :user
+          "actor_id::text = #{quote(actor_filter[:id])} AND actor_type = #{quote(actor_filter[:type])}"
+        when :sys
+          "actor_id IS NULL AND metadata->>'actor' = #{quote(actor_filter[:name])}"
+        when :anon
+          "actor_id IS NULL AND NOT (metadata ? 'actor')"
+        end
+      end
+
+      def search_clause(columns)
+        query = filters.query.strip
+        return nil if query.empty?
+
+        pattern = ActiveRecord::Base.sanitize_sql_like(query)
+        like = quote("%#{pattern}%")
+        "(#{columns.map { |column| "#{column} ILIKE #{like}" }.join(" OR ")})"
+      end
+
+      def tables_for_model_clause
+        tables_in_clause(registry.select { |model| model.record_type == filters.model })
+      end
+
+      def tables_with_mode_clause(mode)
+        tables_in_clause(registry.select { |model| model.capture_mode == mode })
+      end
+
+      # Compose `(schema_name, table_name) IN (VALUES …)` from a list of models,
+      # or "FALSE" when there are no matching tables — a bare IN over an empty
+      # VALUES list is invalid Postgres, so the clause itself collapses.
+      def tables_in_clause(models)
+        return "FALSE" if models.empty?
+
+        tuples = models.map { |model| "(#{quote(model.schema)}, #{quote(model.table)})" }.join(",")
+        "(schema_name, table_name) IN (VALUES #{tuples})"
+      end
+
+      def registry
+        @registry ||= ModelRegistry.discover
+      end
+
+      def quote(value)
+        ActiveRecord::Base.connection.quote(value)
+      end
+
+      def to_row(hash)
+        {
+          kind: hash["kind"],
+          id: hash["id"].to_i,
+          record_type: hash["record_type"],
+          record_id: hash["record_id"],
+          schema_name: hash["schema_name"],
+          table_name: hash["table_name"],
+          actor_type: hash["actor_type"],
+          actor_id: hash["actor_id"],
+          occurred_at: parse_time(hash["occurred_at"]),
+          record_data: parse_jsonb(hash["record_data"]),
+          metadata: parse_jsonb(hash["metadata"])
+        }
+      end
+
+      def parse_time(value)
+        return value if value.is_a?(Time)
+        return nil if value.nil?
+
+        Time.zone.parse(value.to_s)
+      end
+
+      def parse_jsonb(value)
+        return value if value.is_a?(Hash) || value.is_a?(Array)
+        return nil if value.nil?
+        return value unless value.is_a?(String)
+
+        JSON.parse(value)
+      rescue JSON::ParserError
+        value
+      end
+    end
+  end
+end

data/lib/athar/dashboard/filter_set.rb

@@ -0,0 +1,63 @@
+# frozen_string_literal: true
+
+module Athar
+  module Dashboard
+    # Immutable value object holding the parsed query-param state for a
+    # dashboard request. Exposed by DashboardController#index as @filters and
+    # consumed by FeedQuery, KpiCalculator, ActorOptions, and the partials.
+    class FilterSet
+      TIMES = { "24h" => 24.hours, "7d" => 7.days, "30d" => 30.days, "all" => nil }.freeze
+      MODES = %w[all identity only snapshot].freeze
+      KINDS = %w[all delete truncate].freeze
+      DEFAULT_TIME = "30d"
+
+      attr_reader :model, :time, :mode, :kind, :actor, :query, :page, :expanded
+
+      def self.from_params(params) # rubocop:disable Metrics/AbcSize
+        new(
+          model: params[:model].presence,
+          time: TIMES.key?(params[:time]) ? params[:time] : DEFAULT_TIME,
+          mode: MODES.include?(params[:mode]) ? params[:mode] : "all",
+          kind: KINDS.include?(params[:kind]) ? params[:kind] : "all",
+          actor: params[:actor].presence || "all",
+          query: params[:q].to_s,
+          page: [params[:page].to_i, 1].max,
+          expanded: params[:expanded].presence
+        )
+      end
+
+      def initialize(model:, time:, mode:, kind:, actor:, query:, page:, expanded:) # rubocop:disable Metrics/ParameterLists
+        @model = model
+        @time = time
+        @mode = mode
+        @kind = kind
+        @actor = actor
+        @query = query
+        @page = page
+        @expanded = expanded
+
+        freeze
+      end
+
+      def time_cutoff(now = Time.current)
+        delta = TIMES[time]
+        delta ? now - delta : nil
+      end
+
+      def actor_filter
+        return nil if actor == "all"
+
+        if actor == "anon"
+          { kind: :anon }
+        elsif actor.start_with?("user:")
+          _, type, id = actor.split(":", 3)
+          return nil if id.blank?
+
+          { kind: :user, type:, id: }
+        elsif actor.start_with?("sys:")
+          { kind: :sys, name: actor.sub("sys:", "") }
+        end
+      end
+    end
+  end
+end

data/lib/athar/dashboard/kpi_calculator.rb

@@ -0,0 +1,102 @@
+# frozen_string_literal: true
+
+module Athar
+  module Dashboard
+    class KpiCalculator
+      Result = Data.define(
+        :scope_total,
+        :last_24h,
+        :last_7d,
+        :prior_7d,
+        :distinct_actors_30d,
+        :truncates_30d,
+        :sparkline
+      )
+
+      def initialize(model:, now: Time.current, registry: nil)
+        @model = model
+        @now = now
+        @registry = registry
+      end
+
+      def call(connection: ActiveRecord::Base.connection) # rubocop:disable Metrics/AbcSize
+        aggregates = aggregate(connection)
+        truncates_30d = truncate_count(connection)
+
+        Result.new(
+          # scope_total covers the same universe the feed UNIONs over: row
+          # deletions plus all table events for the model's tables (not just
+          # the last 30d), so "filtered N of M" never overshoots M.
+          scope_total: aggregates["scope_total"].to_i + table_event_total(connection),
+          last_24h: aggregates["last_24h"].to_i,
+          last_7d: aggregates["last_7d"].to_i,
+          prior_7d: aggregates["prior_7d"].to_i,
+          distinct_actors_30d: aggregates["distinct_actors_30d"].to_i,
+          truncates_30d: truncates_30d,
+          sparkline: Sparkline.new(model: @model, now: @now).buckets(connection: connection)
+        )
+      end
+
+      private
+
+      def aggregate(connection) # rubocop:disable Metrics/AbcSize
+        sql = <<~SQL
+          SELECT
+            COUNT(*) AS scope_total,
+            COUNT(*) FILTER (WHERE deleted_at > #{quote(@now - 1.day)}) AS last_24h,
+            COUNT(*) FILTER (WHERE deleted_at > #{quote(@now - 7.days)}) AS last_7d,
+            COUNT(*) FILTER (WHERE deleted_at > #{quote(@now - 14.days)}
+                               AND deleted_at <= #{quote(@now - 7.days)}) AS prior_7d,
+            COUNT(DISTINCT (actor_type, actor_id))
+              FILTER (WHERE actor_id IS NOT NULL AND deleted_at > #{quote(@now - 30.days)}) AS distinct_actors_30d
+          FROM #{Athar::DELETIONS_TABLE_NAME}
+          #{model_scope}
+        SQL
+
+        connection.select_one(sql)
+      end
+
+      def truncate_count(connection)
+        sql = <<~SQL
+          SELECT COUNT(*) AS n FROM #{Athar::TABLE_EVENTS_TABLE_NAME}
+          WHERE event_type = 'truncate' AND occurred_at > #{quote(@now - 30.days)}
+          #{table_scope_clause}
+        SQL
+        connection.select_value(sql).to_i
+      end
+
+      def table_event_total(connection)
+        sql = <<~SQL
+          SELECT COUNT(*) AS n FROM #{Athar::TABLE_EVENTS_TABLE_NAME}
+          WHERE TRUE #{table_scope_clause}
+        SQL
+
+        connection.select_value(sql).to_i
+      end
+
+      def model_scope
+        return "" unless @model
+
+        "WHERE record_type = #{quote(@model)}"
+      end
+
+      def table_scope_clause
+        return "" unless @model
+
+        scoped = registry.select { |model| model.record_type == @model }
+        return "AND FALSE" if scoped.empty?
+
+        pairs = scoped.map { |model| "(#{quote(model.schema)}, #{quote(model.table)})" }.join(",")
+        "AND (schema_name, table_name) IN (VALUES #{pairs})"
+      end
+
+      def registry
+        @registry ||= ModelRegistry.discover
+      end
+
+      def quote(value)
+        ActiveRecord::Base.connection.quote(value)
+      end
+    end
+  end
+end

data/lib/athar/dashboard/model_registry.rb

@@ -0,0 +1,141 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Athar
+  module Dashboard
+    module ModelRegistry
+      ModelInfo = Data.define(:schema, :table, :record_type, :capture_mode, :columns, :masks, :sti, :truncate, :count)
+
+      DELETE_TRIGGER_SQL = <<~SQL
+        SELECT n.nspname AS schema_name, c.relname AS table_name,
+               pg_get_triggerdef(t.oid) AS definition
+        FROM pg_trigger t
+        JOIN pg_proc p ON p.oid = t.tgfoid
+        JOIN pg_class c ON c.oid = t.tgrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE p.proname = 'athar_capture_delete' AND NOT t.tgisinternal
+      SQL
+
+      TRUNCATE_TRIGGER_SQL = <<~SQL
+        SELECT n.nspname AS schema_name, c.relname AS table_name
+        FROM pg_trigger t
+        JOIN pg_proc p ON p.oid = t.tgfoid
+        JOIN pg_class c ON c.oid = t.tgrelid
+        JOIN pg_namespace n ON n.oid = c.relnamespace
+        WHERE p.proname = 'athar_capture_truncate' AND NOT t.tgisinternal
+      SQL
+
+      COUNTS_SQL = <<~SQL.freeze
+        SELECT schema_name, table_name, record_type, COUNT(*) AS n
+        FROM #{Athar::DELETIONS_TABLE_NAME}
+        GROUP BY schema_name, table_name, record_type
+      SQL
+
+      ARGS_RE         = /EXECUTE\s+(?:PROCEDURE|FUNCTION)\s+athar_capture_delete\((.*)\)/m
+      PG_ARRAY_QUOTED = /"([^"]*)"/
+      PG_ARRAY_BARE   = /[^,]+/
+
+      class << self
+        def discover(connection = ActiveRecord::Base.connection) # rubocop:disable Metrics/AbcSize,Metrics/CyclomaticComplexity,Metrics/MethodLength,Metrics/PerceivedComplexity
+          triggers = parse_delete_triggers(connection)
+          truncate_keys = truncate_trigger_keys(connection)
+          counts = load_counts(connection)
+
+          # One ModelInfo per (schema, table) trigger.
+          primary = triggers.map do |trigger|
+            key = [trigger[:schema], trigger[:table]]
+
+            ModelInfo.new(
+              schema: trigger[:schema],
+              table: trigger[:table],
+              record_type: trigger[:record_type] || trigger[:table].classify,
+              capture_mode: trigger[:capture_mode],
+              columns: trigger[:columns],
+              masks: trigger[:masks],
+              sti: trigger[:sti],
+              truncate: truncate_keys.include?(key),
+              count: counts.fetch(
+                [trigger[:schema], trigger[:table], trigger[:record_type] || trigger[:table].classify],
+                0
+              )
+            )
+          end
+
+          # STI children: any (schema, table, record_type) in counts that doesn't
+          # match a primary's record_type but whose (schema, table) has STI on.
+          children = counts.filter_map do |(schema, table, record_type), n|
+            parent = primary.find { |entry| entry.schema == schema && entry.table == table }
+            next unless parent&.sti && parent.record_type != record_type
+
+            ModelInfo.new(
+              schema:,
+              table:,
+              record_type:,
+              capture_mode: parent.capture_mode,
+              columns: parent.columns,
+              masks: parent.masks,
+              sti: true,
+              truncate: parent.truncate,
+              count: n
+            )
+          end
+
+          primary + children
+        end
+
+        private
+
+        def parse_delete_triggers(connection) # rubocop:disable Metrics/AbcSize
+          connection.select_all(DELETE_TRIGGER_SQL).map do |row|
+            arguments_text = row["definition"][ARGS_RE, 1]
+            args = TriggerArgsParser.parse(arguments_text)
+
+            {
+              schema: row["schema_name"],
+              table: row["table_name"],
+              record_type: args[0],
+              capture_mode: args[6],
+              columns: parse_pg_array(args[7]),
+              masks: parse_pg_array(args[8]).map { |spec| spec.split(":").first },
+              sti: !args[5].nil?
+            }
+          end
+        end
+
+        def truncate_trigger_keys(connection)
+          connection.select_all(TRUNCATE_TRIGGER_SQL).each_with_object(Set.new) do |row, set|
+            set << [row["schema_name"], row["table_name"]]
+          end
+        end
+
+        def load_counts(connection)
+          connection.select_all(COUNTS_SQL).to_h do |row|
+            [[row["schema_name"], row["table_name"], row["record_type"]], row["n"].to_i]
+          end
+        end
+
+        # PG array text: '{a,b,c}' or '{"a:b","c:d"}'. Each token is either a
+        # "..."-quoted string (content captured) or a bare token up to the
+        # next comma.
+        def parse_pg_array(text)
+          return [] if text.nil? || text == "null"
+
+          inner = text.delete_prefix("{").delete_suffix("}")
+          return [] if inner.empty?
+
+          scanner = StringScanner.new(inner)
+          parts = []
+
+          until scanner.eos?
+            parts << (scanner.scan(PG_ARRAY_QUOTED) ? scanner[1] : scanner.scan(PG_ARRAY_BARE))
+
+            scanner.skip(/,/)
+          end
+
+          parts.compact
+        end
+      end
+    end
+  end
+end

data/lib/athar/dashboard/sparkline.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+module Athar
+  module Dashboard
+    class Sparkline
+      DAYS = 14
+
+      def initialize(model:, now: Time.current)
+        @model = model
+        @now = now
+      end
+
+      def buckets(connection: ActiveRecord::Base.connection) # rubocop:disable Metrics/AbcSize
+        rows = connection.select_all(<<~SQL).to_a
+          SELECT date_trunc('day', deleted_at) AS day, COUNT(*) AS n
+          FROM #{Athar::DELETIONS_TABLE_NAME}
+          WHERE deleted_at > #{quote(@now - DAYS.days)} #{model_scope}
+          GROUP BY day ORDER BY day
+        SQL
+
+        by_day = rows.to_h do |row|
+          [row["day"].to_date, row["n"].to_i]
+        end
+
+        Array.new(DAYS) do |index|
+          day = (@now.to_date - (DAYS - 1 - index))
+          by_day.fetch(day, 0)
+        end
+      end
+
+      private
+
+      def model_scope
+        @model ? "AND record_type = #{quote(@model)}" : ""
+      end
+
+      def quote(value)
+        ActiveRecord::Base.connection.quote(value)
+      end
+    end
+  end
+end

data/lib/athar/dashboard/trigger_args_parser.rb

@@ -0,0 +1,42 @@
+# frozen_string_literal: true
+
+require "strscan"
+
+module Athar
+  module Dashboard
+    # Parses the comma-separated argument list captured from a trigger's
+    # `EXECUTE PROCEDURE athar_capture_delete(...)` clause. Every arg is a
+    # single-quoted string per the trigger templates, so the parser walks
+    # quoted tokens (honoring PG's `''` escape for embedded apostrophes) and
+    # maps the literal "null" token to Ruby nil.
+    module TriggerArgsParser
+      QUOTED_TOKEN = /'((?:[^']|'')*)'/
+      SEPARATOR    = /[\s,]+/
+
+      class << self
+        def parse(input)
+          scanner = StringScanner.new(input)
+          args = []
+
+          until scanner.eos?
+            scanner.skip(SEPARATOR)
+            break if scanner.eos?
+            break unless scanner.scan(QUOTED_TOKEN)
+
+            args << finalize(scanner[1].gsub("''", "'"))
+          end
+
+          args
+        end
+
+        private
+
+        def finalize(token)
+          return nil if token == "null"
+
+          token
+        end
+      end
+    end
+  end
+end

data/lib/athar/dashboard.rb

@@ -0,0 +1,16 @@
+# frozen_string_literal: true
+
+module Athar
+  module Dashboard
+  end
+end
+
+require_relative "dashboard/filter_set"
+require_relative "dashboard/trigger_args_parser"
+require_relative "dashboard/model_registry"
+require_relative "dashboard/feed_query"
+require_relative "dashboard/sparkline"
+require_relative "dashboard/kpi_calculator"
+require_relative "dashboard/actor_labels"
+require_relative "dashboard/actor_options"
+require_relative "dashboard/connection_info"

data/lib/athar/engine.rb

@@ -1,5 +1,7 @@
 # frozen_string_literal: true
 
+require_relative "middleware/asset_server"
+
 module Athar
   class Engine < ::Rails::Engine
     isolate_namespace Athar
@@ -7,5 +9,15 @@ module Athar
     initializer "athar.set_logger" do
       Athar.configuration.logger ||= Rails.logger
     end
+
+    initializer "athar.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.paths << root.join("app/assets/stylesheets").to_s
+        app.config.assets.paths << root.join("app/assets/javascripts").to_s
+        app.config.assets.precompile += %w[athar/dashboard.js athar/dashboard.css] if defined?(::Sprockets)
+      end
+
+      app.middleware.insert_after Rack::Runtime, Athar::Middleware::AssetServer, root
+    end
   end
 end