airview 0.1.0

data/db/migrate/20260806000000_create_airview_views.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+class CreateAirviewViews < ActiveRecord::Migration[7.1]
+  def change
+    create_table :airview_resources do |t|
+      t.string :key, null: false
+      t.string :record_class_name, null: false
+      t.string :label, null: false
+      t.string :label_method
+      t.boolean :enabled, null: false, default: false
+      t.integer :position, null: false, default: 0
+      t.json :metadata, null: false, default: {}
+
+      t.timestamps
+    end
+
+    add_index :airview_resources, :key, unique: true
+    add_index :airview_resources, :record_class_name, unique: true
+    add_index :airview_resources, :enabled
+
+    create_table :airview_fields do |t|
+      t.references :airview_resource, null: false, foreign_key: { to_table: :airview_resources }
+      t.string :name, null: false
+      t.string :label, null: false
+      t.string :field_type, null: false
+      t.boolean :visible, null: false, default: true
+      t.boolean :read_only, null: false, default: false
+      t.integer :position, null: false, default: 0
+      t.string :association_name
+      t.string :target_model_name
+      t.string :target_label_method
+      t.json :metadata, null: false, default: {}
+
+      t.timestamps
+    end
+
+    add_index :airview_fields, %i[airview_resource_id name], unique: true
+    add_index :airview_fields, :visible
+
+    create_table :airview_views do |t|
+      t.string :name, null: false
+      t.string :resource_key, null: false
+      t.string :owner_key
+      t.string :folder
+      t.json :columns, null: false, default: []
+      t.json :filters, null: false, default: {}
+      t.json :sorts, null: false, default: {}
+      t.json :preferences, null: false, default: {}
+
+      t.timestamps
+    end
+
+    add_index :airview_views, :resource_key
+    add_index :airview_views, %i[resource_key folder]
+    add_index :airview_views, %i[resource_key name]
+  end
+end

data/lib/airview/configuration.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+
+module Airview
+  class Configuration
+  end
+end

data/lib/airview/engine.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require "rails"
+
+module Airview
+  class Engine < ::Rails::Engine
+    isolate_namespace Airview
+
+    initializer "airview.assets" do |app|
+      if app.config.respond_to?(:assets)
+        app.config.assets.precompile += %w[airview/application.css airview/application.js]
+      end
+    end
+  end
+end

data/lib/airview/field.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+module Airview
+  class Field
+    TYPES = %i[
+      string text integer float decimal boolean date datetime select belongs_to has_many attachment json
+    ].freeze
+
+    attr_reader :name, :label, :type, :options, :model, :label_method
+
+    def initialize(name, type:, label: nil, readonly: false, options: nil, model: nil, label_method: nil,
+                   default_visible: true)
+      @name = name.to_sym
+      @label = label.presence || name.to_s.humanize
+      @type = type.to_sym
+      @readonly = readonly
+      @options = options
+      @model = model
+      @label_method = label_method || :to_s
+      @default_visible = default_visible
+    end
+
+    def readonly?
+      @readonly
+    end
+
+    def editable?
+      !readonly? && !display_only?
+    end
+
+    def default_visible?
+      @default_visible
+    end
+
+    def association?
+      type.in?(%i[belongs_to has_many])
+    end
+
+    def collection_association?
+      type == :has_many
+    end
+
+    def attachment?
+      type == :attachment
+    end
+
+    def display_only?
+      collection_association? || attachment?
+    end
+
+    def filterable?
+      !display_only?
+    end
+
+    def sortable?
+      !display_only?
+    end
+
+    def attribute_name
+      type == :belongs_to ? :"#{name}_id" : name
+    end
+
+    def validate!
+      return if TYPES.include?(type)
+
+      raise ConfigurationError, "Unsupported Airview field type #{type.inspect} for #{name}"
+    end
+
+    def model_class
+      return nil unless model
+
+      model.to_s.constantize
+    end
+
+    def option_values
+      return [] unless options
+
+      options.respond_to?(:call) ? options.call : options
+    end
+  end
+end

data/lib/airview/model_discovery.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+module Airview
+  class ModelDiscovery
+    EXCLUDED_NAMESPACES = %w[Airview ActiveStorage ActionMailbox ActionText].freeze
+
+    class << self
+      def models
+        eager_load_application
+
+        ActiveRecord::Base.descendants
+                          .select { |model| eligible?(model) }
+                          .sort_by(&:name)
+      end
+
+      def model_named(name)
+        models.find { |model| model.name == name.to_s }
+      end
+
+      private
+
+      def eager_load_application
+        Rails.application.eager_load! if defined?(Rails) && Rails.application
+      rescue Zeitwerk::NameError
+        nil
+      end
+
+      def eligible?(model)
+        model.name.present? &&
+          EXCLUDED_NAMESPACES.none? { |namespace| model.name.start_with?("#{namespace}::") } &&
+          !model.abstract_class? &&
+          model.table_exists?
+      rescue ActiveRecord::StatementInvalid, ActiveRecord::NoDatabaseError
+        false
+      end
+    end
+  end
+end

data/lib/airview/query.rb

@@ -0,0 +1,194 @@
+# frozen_string_literal: true
+
+module Airview
+  class Query
+    DEFAULT_LIMIT = 50
+    MAX_LIMIT = 200
+
+    attr_reader :resource, :params
+
+    def initialize(resource, params = {})
+      @resource = resource
+      @params = params || {}
+    end
+
+    def records
+      scope = resource.model_class.all
+      scope = apply_search(scope)
+      scope = apply_filters(scope)
+      scope = apply_sort(scope)
+      scope.limit(limit).offset(offset)
+    end
+
+    def count
+      apply_filters(apply_search(resource.model_class.all)).count
+    end
+
+    def limit
+      value = params[:limit].presence || DEFAULT_LIMIT
+      [[value.to_i, 1].max, MAX_LIMIT].min
+    end
+
+    def page
+      [params[:page].to_i, 1].max
+    end
+
+    def offset
+      (page - 1) * limit
+    end
+
+    private
+
+    def apply_search(scope)
+      term = params[:q].to_s.strip
+      return scope if term.empty?
+
+      searchable = resource.fields.values.select { |field| %i[string text select].include?(field.type) }
+      return scope if searchable.empty?
+
+      clauses = searchable.map do |field|
+        scope.klass.arel_table[field.attribute_name].matches("%#{sanitize_like(term)}%")
+      end
+      scope.where(clauses.reduce { |query, clause| query.or(clause) })
+    end
+
+    def apply_filters(scope)
+      filters = params[:filters].respond_to?(:to_unsafe_h) ? params[:filters].to_unsafe_h : params[:filters]
+      return scope if filters.blank?
+
+      return apply_structured_filters(scope, filters) if structured_filters?(filters)
+
+      filters.each do |name, value|
+        next if value.blank?
+
+        field = resource.fields[name.to_sym]
+        next unless field
+
+        scope = apply_filter(scope, field, value)
+      end
+      scope
+    end
+
+    def structured_filters?(filters)
+      filters.is_a?(Array) || filters.values.first.respond_to?(:key?)
+    rescue NoMethodError
+      false
+    end
+
+    def apply_structured_filters(scope, filters)
+      Array(filters.is_a?(Hash) ? filters.values : filters).each do |condition|
+        condition = condition.to_unsafe_h if condition.respond_to?(:to_unsafe_h)
+        condition = condition.to_h.stringify_keys
+        field = resource.fields[condition["field"].to_s.to_sym]
+        next unless field
+        next unless field.filterable?
+
+        scope = apply_structured_filter(scope, field, condition["operator"], condition["value"])
+      end
+      scope
+    end
+
+    def apply_filter(scope, field, value)
+      case field.type
+      when :string, :text, :select
+        scope.where(scope.klass.arel_table[field.attribute_name].matches("%#{sanitize_like(value)}%"))
+      when :boolean
+        scope.where(field.attribute_name => ActiveModel::Type::Boolean.new.cast(value))
+      when :integer
+        scope.where(field.attribute_name => value.to_i)
+      else
+        scope.where(field.attribute_name => value)
+      end
+    end
+
+    def apply_structured_filter(scope, field, operator, value)
+      return apply_empty_filter(scope, field, operator) if operator.to_s.in?(%w[is_empty is_not_empty])
+      return scope if value.blank? && field.type != :boolean
+
+      case field.type
+      when :string, :text, :select, :json
+        apply_text_filter(scope, field, operator, value)
+      when :boolean
+        apply_boolean_filter(scope, field, operator, value)
+      when :integer, :float, :decimal
+        apply_numeric_filter(scope, field, operator, value)
+      when :date, :datetime
+        apply_date_filter(scope, field, operator, value)
+      else
+        scope.where(field.attribute_name => value)
+      end
+    end
+
+    def apply_empty_filter(scope, field, operator)
+      empty_values = %i[string text select json].include?(field.type) ? [nil, ""] : [nil]
+
+      if operator == "is_not_empty"
+        scope.where.not(field.attribute_name => empty_values)
+      else
+        scope.where(field.attribute_name => empty_values)
+      end
+    end
+
+    def apply_text_filter(scope, field, operator, value)
+      column = scope.klass.arel_table[field.attribute_name]
+
+      case operator
+      when "equals"
+        scope.where(field.attribute_name => value)
+      when "starts_with"
+        scope.where(column.matches("#{sanitize_like(value)}%"))
+      else
+        scope.where(column.matches("%#{sanitize_like(value)}%"))
+      end
+    end
+
+    def apply_boolean_filter(scope, field, operator, value)
+      boolean = case operator
+                when "is_true"
+                  true
+                when "is_false"
+                  false
+                else
+                  ActiveModel::Type::Boolean.new.cast(value)
+                end
+
+      scope.where(field.attribute_name => boolean)
+    end
+
+    def apply_numeric_filter(scope, field, operator, value)
+      operators = { "gt" => ">", "lt" => "<", "gte" => ">=", "lte" => "<=" }
+      sql_operator = operators[operator.to_s]
+      return scope.where(field.attribute_name => value) unless sql_operator
+
+      column = scope.connection.quote_column_name(field.attribute_name)
+      scope.where("#{column} #{sql_operator} ?", value)
+    end
+
+    def apply_date_filter(scope, field, operator, value)
+      case operator
+      when "before"
+        scope.where(scope.klass.arel_table[field.attribute_name].lt(value))
+      when "after"
+        scope.where(scope.klass.arel_table[field.attribute_name].gt(value))
+      else
+        scope.where(field.attribute_name => value)
+      end
+    end
+
+    def apply_sort(scope)
+      sort = params[:sort].to_s
+      return scope if sort.empty?
+
+      direction = params[:direction].to_s.downcase == "desc" ? :desc : :asc
+      field = resource.fields[sort.to_sym]
+      return scope unless field
+      return scope unless field.sortable?
+
+      scope.order(field.attribute_name => direction)
+    end
+
+    def sanitize_like(value)
+      ActiveRecord::Base.sanitize_sql_like(value.to_s)
+    end
+  end
+end

data/lib/airview/resource.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Airview
+  class Resource
+    attr_accessor :label, :label_method
+    attr_reader :key, :model, :fields
+
+    def initialize(key, model:)
+      @key = key.to_sym
+      @model = model
+      @label = key.to_s.humanize
+      @label_method = :to_s
+      @fields = {}
+    end
+
+    def field(name, type:, label: nil, **options)
+      definition = Field.new(name, type:, label:, **options)
+      definition.validate!
+      fields[definition.name] = definition
+      definition
+    end
+
+    def model_class
+      model.to_s.constantize
+    end
+
+    def field!(name)
+      fields.fetch(name.to_sym) do
+        raise ConfigurationError, "Unknown Airview field #{name.inspect} for #{key}"
+      end
+    end
+
+    def editable_fields
+      fields.values.select(&:editable?)
+    end
+
+    def default_fields
+      fields.values.select(&:default_visible?)
+    end
+
+    def validate!
+      raise ConfigurationError, "Airview resource #{key} must define at least one field" if fields.empty?
+
+      fields.each_value(&:validate!)
+    end
+
+    def record_label(record)
+      Airview.record_label(record, label_method)
+    end
+  end
+end

data/lib/airview/resource_builder.rb

@@ -0,0 +1,62 @@
+# frozen_string_literal: true
+
+module Airview
+  class ResourceBuilder
+    class << self
+      def enabled_resources
+        definitions = Airview::ResourceDefinition.enabled.includes(:field_definitions).order(:position, :label)
+
+        definitions.each_with_object({}) do |definition, resources|
+          resource = build(definition)
+          resources[resource.key] = resource
+        end
+      end
+
+      def build(definition)
+        Resource.new(definition.key, model: definition.record_class_name).tap do |resource|
+          resource.label = definition.label
+          resource.label_method = definition.label_method.presence&.to_sym || :to_s
+
+          definition.field_definitions.visible.order(:position, :name).each do |field|
+            add_field(resource, field)
+          end
+
+          add_missing_virtual_fields(resource, definition)
+        end
+      end
+
+      private
+
+      def add_field(resource, field)
+        resource.field(
+          field.name,
+          type: field.field_type,
+          label: field.label,
+          readonly: field.read_only?,
+          model: field.target_model_name,
+          label_method: field.target_label_method.presence&.to_sym,
+          default_visible: field.default_visible?
+        )
+      end
+
+      def add_missing_virtual_fields(resource, definition)
+        defined_names = definition.field_definitions.map { |field| field.name.to_sym }
+
+        SchemaInference.new(resource.model_class).field_attributes.each do |attributes|
+          next unless attributes[:field_type].to_sym.in?(%i[has_many attachment])
+          next if defined_names.include?(attributes[:name].to_sym)
+
+          resource.field(
+            attributes[:name],
+            type: attributes[:field_type],
+            label: attributes[:label],
+            readonly: attributes[:read_only],
+            model: attributes[:target_model_name],
+            label_method: attributes[:target_label_method],
+            default_visible: attributes.dig(:metadata, :default_visible)
+          )
+        end
+      end
+    end
+  end
+end

data/lib/airview/schema_inference.rb

@@ -0,0 +1,196 @@
+# frozen_string_literal: true
+
+module Airview
+  class SchemaInference
+    SENSITIVE_PATTERNS = [
+      /password/i,
+      /token/i,
+      /secret/i,
+      /api[_-]?key/i,
+      /credential/i,
+      /encrypted/i,
+      /digest/i,
+      /reset/i,
+      /remember/i
+    ].freeze
+
+    TYPE_MAP = {
+      string: :string,
+      text: :text,
+      integer: :integer,
+      float: :float,
+      decimal: :decimal,
+      boolean: :boolean,
+      date: :date,
+      datetime: :datetime,
+      timestamp: :datetime,
+      json: :json,
+      jsonb: :json
+    }.freeze
+
+    attr_reader :model
+
+    def initialize(model)
+      @model = model
+    end
+
+    def resource_attributes
+      {
+        key: model.model_name.route_key,
+        record_class_name: model.name,
+        label: model.model_name.human(count: 2),
+        label_method: inferred_label_method,
+        enabled: false,
+        metadata: {
+          table_name: model.table_name,
+          inferred_at: Time.current.iso8601
+        }
+      }
+    end
+
+    def field_attributes
+      column_fields = model.columns.each_with_index.filter_map do |column, index|
+        next if sensitive?(column.name)
+
+        field_attributes_for(column, index)
+      end
+
+      column_fields + virtual_field_attributes(column_fields.length)
+    end
+
+    private
+
+    def virtual_field_attributes(starting_position)
+      collection_fields = collection_field_attributes(starting_position)
+      attachment_fields = attachment_field_attributes(starting_position + collection_fields.length)
+
+      collection_fields + attachment_fields
+    end
+
+    def collection_field_attributes(starting_position)
+      model.reflect_on_all_associations(:has_many).each_with_index.filter_map do |association, index|
+        target_class = association_class(association)
+        next unless target_class
+
+        {
+          name: association.name,
+          label: association.name.to_s.humanize,
+          field_type: :has_many,
+          visible: true,
+          read_only: true,
+          position: starting_position + index,
+          association_name: association.name,
+          target_model_name: target_class.name,
+          target_label_method: label_method_for(target_class),
+          metadata: {
+            default_visible: false,
+            macro: association.macro.to_s
+          }
+        }
+      end
+    rescue NameError
+      []
+    end
+
+    def attachment_field_attributes(starting_position)
+      return [] unless model.respond_to?(:attachment_reflections)
+
+      model.attachment_reflections.values.each_with_index.map do |reflection, index|
+        {
+          name: reflection.name,
+          label: reflection.name.to_s.humanize,
+          field_type: :attachment,
+          visible: true,
+          read_only: true,
+          position: starting_position + index,
+          association_name: reflection.name,
+          target_model_name: nil,
+          target_label_method: nil,
+          metadata: {
+            default_visible: false,
+            macro: reflection.macro.to_s
+          }
+        }
+      end
+    end
+
+    def field_attributes_for(column, index)
+      association = belongs_to_association_for(column.name)
+      target_class = association_class(association)
+      name = association&.name || column.name
+      association_supported = association && target_class
+
+      {
+        name:,
+        label: name.to_s.humanize,
+        field_type: inferred_field_type(column, association_supported),
+        visible: true,
+        read_only: inferred_readonly?(column, association),
+        position: index,
+        association_name: association_supported ? association.name : nil,
+        target_model_name: target_class&.name,
+        target_label_method: target_class ? label_method_for(target_class) : nil,
+        metadata: column_metadata(column)
+      }
+    end
+
+    def belongs_to_association_for(column_name)
+      return nil unless column_name.end_with?("_id")
+
+      model.reflect_on_all_associations(:belongs_to).find do |association|
+        association.foreign_key.to_s == column_name
+      end
+    rescue NameError
+      nil
+    end
+
+    def association_class(association)
+      return nil if association&.polymorphic?
+
+      association&.klass
+    rescue ArgumentError, NameError
+      nil
+    end
+
+    def unsupported_association?(association)
+      association && !association_class(association)
+    end
+
+    def field_type(column)
+      TYPE_MAP.fetch(column.type, :string)
+    end
+
+    def inferred_field_type(column, association_supported)
+      association_supported ? :belongs_to : field_type(column)
+    end
+
+    def inferred_readonly?(column, association)
+      readonly?(column) || unsupported_association?(association)
+    end
+
+    def readonly?(column)
+      column.name == model.primary_key || column.name.in?(%w[created_at updated_at])
+    end
+
+    def sensitive?(name)
+      SENSITIVE_PATTERNS.any? { |pattern| name.match?(pattern) }
+    end
+
+    def inferred_label_method
+      label_method_for(model)
+    end
+
+    def label_method_for(klass)
+      %i[name title email username slug].find { |method| klass.column_names.include?(method.to_s) } || :to_s
+    end
+
+    def column_metadata(column)
+      {
+        sql_type: column.sql_type,
+        null: column.null,
+        default: column.default,
+        primary_key: column.name == model.primary_key
+      }
+    end
+  end
+end

data/lib/airview/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Airview
+  VERSION = "0.1.0"
+end