infotable 1.4.1 → 1.6.0

data/lib/infotable/base.rb

@@ -1,7 +1,12 @@
 module Infotable
   class Base
+    # Options column accepts; anything else is logged as a probable typo
+    COLUMN_OPTIONS = %i[label type sortable searchable filterable visible exportable pinned virtual virtual_sql
+                        sql sort_sql value includes formatter formatter_options actions filter_type filter_options
+                        filter_options_cache filter_options_limit filter_multi_select width].freeze
+
     class << self
-      attr_accessor :table_columns, :table_query, :table_query_sql, :pagination_settings, :sort_settings, :height_settings, :infinite_scroll_settings, :row_link_settings, :slim_rows_settings, :row_size_settings, :filters_button_settings, :display_settings, :nil_value_settings, :empty_value_settings, :table_authorize, :checkbox_settings, :batch_action_list, :countless_setting, :url_state_setting, :resizable_columns_setting
+      attr_accessor :table_columns, :table_query, :table_query_sql, :pagination_settings, :sort_settings, :height_settings, :infinite_scroll_settings, :row_link_settings, :row_attr_settings, :slim_rows_settings, :row_size_settings, :filters_button_settings, :display_settings, :nil_value_settings, :empty_value_settings, :table_authorize, :checkbox_settings, :batch_action_list, :countless_setting, :url_state_setting, :resizable_columns_setting
 
       def inherited(subclass)
         super
@@ -19,6 +24,7 @@ module Infotable
         subclass.infinite_scroll_settings = {
           enabled: false
         }
+        subclass.row_attr_settings = { class: nil, data: nil }
         subclass.row_link_settings = {
           enabled: false,
           url: nil
@@ -65,7 +71,9 @@ module Infotable
         subclass.countless_setting = parent.countless_setting
         subclass.url_state_setting = parent.url_state_setting
         subclass.resizable_columns_setting = parent.resizable_columns_setting
-        %i[pagination_settings sort_settings height_settings infinite_scroll_settings row_link_settings
+        subclass.instance_variable_set(:@toolbar_setting, parent.instance_variable_get(:@toolbar_setting))
+        subclass.instance_variable_set(:@export_column_names, parent.instance_variable_get(:@export_column_names)&.dup)
+        %i[pagination_settings sort_settings height_settings infinite_scroll_settings row_link_settings row_attr_settings
            slim_rows_settings row_size_settings filters_button_settings display_settings
            nil_value_settings empty_value_settings].each do |attr|
           subclass.public_send("#{attr}=", parent.public_send(attr).dup)
@@ -134,8 +142,9 @@ module Infotable
       # Plucks when the id method is a plain column of an ungrouped query, loads records otherwise.
       def checkbox_ids(query, limit = nil)
         method = @checkbox_settings[:id_method]
-        scope = query.reorder(nil)
-        scope = scope.limit(limit) if limit
+        # Without a cap the order is irrelevant (and costs a sort); with one, the table's own order
+        # decides which rows make it in, so a capped selection is the first N rows the user sees
+        scope = limit ? query.limit(limit) : query.reorder(nil)
         model = query.model
 
         if model.column_names.include?(method.to_s) && scope.group_values.empty? && scope.having_clause.empty?
@@ -169,6 +178,10 @@ module Infotable
       # Define a column
       def column(name, **options)
         @table_columns ||= []
+        unknown = options.keys - COLUMN_OPTIONS
+        if unknown.any? && defined?(Rails) && Rails.logger
+          Rails.logger.warn("[Infotable] #{self.name || 'table'}: column :#{name} ignores unknown option(s) #{unknown.map(&:inspect).join(', ')}")
+        end
         type = options[:type] || :string
 
         # Determine width - use custom if provided and not blank, otherwise use default
@@ -319,6 +332,51 @@ module Infotable
         end
       end
 
+      # Extra CSS classes per row: a String, or a Proc that receives the record (nil/false adds nothing).
+      # Tailwind only generates classes it can see in your source, so write them out in full.
+      # @example
+      #   row_class ->(order) { "bg-red-50" if order.overdue? }
+      def row_class(value = nil, &block)
+        @row_attr_settings[:class] = value || block
+      end
+
+      def row_classes_for(record)
+        setting = @row_attr_settings[:class]
+        (setting.respond_to?(:call) ? setting.call(record) : setting).presence
+      end
+
+      # Extra data-* attributes per row: a Proc that receives the record and returns a Hash
+      # ({ post_id: 1 } becomes data-post-id="1"). Handy for your own Stimulus controllers.
+      # @example
+      #   row_data ->(post) { { post_id: post.id, status: post.status } }
+      def row_data(value = nil, &block)
+        @row_attr_settings[:data] = value || block
+      end
+
+      def row_data_for(record)
+        setting = @row_attr_settings[:data]
+        data = setting.respond_to?(:call) ? setting.call(record) : setting
+        data.is_a?(Hash) ? data : {}
+      end
+
+      # Clicking a row (not a link, button or input inside it) fires a cancelable
+      # `infotable:row-click` event on the row (detail: { id, url, data }). If nothing calls
+      # preventDefault() and the table has a row_link, the click falls back to following it.
+      # @example
+      #   row_click true
+      def row_click(enabled = true)
+        @row_link_settings[:click] = enabled ? true : false
+      end
+
+      def row_click?
+        @row_link_settings[:click] ? true : false
+      end
+
+      # Rows react to clicks (row_link and/or row_click)
+      def row_clickable?
+        row_link_enabled? || row_click?
+      end
+
       # Set row size (padding and text size)
       # @param size [Symbol] - Row size (:slim, :mid, :default)
       # @example

data/lib/infotable/configuration.rb

@@ -31,7 +31,7 @@ module Infotable
       @nil_value = "-" # Default placeholder for nil values
       @empty_value = "-" # Default placeholder for empty strings
       @url_state = true # mirror table state in the address bar
-      @max_select_all = 10_000 # "select all matching" collects at most this many ids (nil = no limit)
+      @max_select_all = 4000 # "select all matching" collects at most this many ids (nil = no limit). Rack accepts 4096 params per request, and every id is sent as ids[]
       @max_filter_options = 500 # select filters render at most this many <option>s (nil = no limit)
       @parent_controller = "ActionController::Base" # Set to "ApplicationController" to inherit host auth/filters
     end

data/lib/infotable/engine.rb

@@ -6,18 +6,11 @@ module Infotable
   class Engine < ::Rails::Engine
     isolate_namespace Infotable
 
-    # Configure engine
-    config.infotable = ActiveSupport::OrderedOptions.new
-
-    # Default configuration values
-    config.infotable.table_min_height = "400px"
-    config.infotable.table_max_height = "600px"
-
     # Rails already adds the engine's app/assets/* directories to the asset path;
     # only the precompile list is needed. Skipped for apps without an asset pipeline.
     initializer "infotable.assets" do |app|
       if app.config.respond_to?(:assets)
-        app.config.assets.precompile += %w[infotable/controllers/*.js]
+        app.config.assets.precompile += %w[infotable/controllers/*.js infotable/vendor/*.js]
       end
     end
 

data/lib/infotable/filter_processor.rb

@@ -110,7 +110,7 @@ module Infotable
       column_name = column[:name]
       is_virtual = having?(column)
       # Use qualified column reference
-      column_ref = qualified_column_ref(column)
+      column_ref = text_ref(column)
 
       result = query
 
@@ -145,6 +145,14 @@ module Infotable
       result
     end
 
+    # PostgreSQL has no LOWER / ILIKE / = '' for numbers, dates, uuids...: a text filter on such a
+    # column (filter_type: :text on an integer) compares its text form.
+    def text_ref(column)
+      ref = qualified_column_ref(column)
+      type = select_column_type(column)
+      type.nil? || %i[string text].include?(type) ? ref : "CAST(#{ref} AS text)"
+    end
+
     # Boolean filter
     def apply_boolean_filter(column, params)
       return query unless params.is_a?(Hash)
@@ -245,6 +253,7 @@ module Infotable
       from = parse_date(scalar(params[:from] || params["from"]))
       to = parse_date(scalar(params[:to] || params["to"]))
       to = to.end_of_day if to && datetime
+      from = from.beginning_of_day if from && datetime # same zone as `to` (Time.zone), not UTC midnight
 
       result = query
       result = result.public_send(filter_method, "#{column_ref} >= ?", from) if from

data/lib/infotable/formatters/boolean_formatter.rb

@@ -10,7 +10,7 @@ module Infotable
         when :badge
           format_as_badge(value, true_text, false_text)
         when :icon
-          format_as_icon(value)
+          format_as_icon(value, true_text, false_text)
         else
           value ? true_text : false_text
         end
@@ -26,11 +26,11 @@ module Infotable
         end
       end
 
-      def format_as_icon(value)
+      def format_as_icon(value, true_text, false_text)
         if value
-          html_safe('<svg class="w-5 h-5 text-green-500" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clip-rule="evenodd"/></svg>')
+          html_safe('<svg class="w-5 h-5 text-green-500" fill="currentColor" viewBox="0 0 20 20" role="img" aria-label="' + ERB::Util.html_escape(true_text) + '"><path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zm3.707-9.293a1 1 0 00-1.414-1.414L9 10.586 7.707 9.293a1 1 0 00-1.414 1.414l2 2a1 1 0 001.414 0l4-4z" clip-rule="evenodd"/></svg>')
         else
-          html_safe('<svg class="w-5 h-5 text-gray-400" fill="currentColor" viewBox="0 0 20 20"><path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clip-rule="evenodd"/></svg>')
+          html_safe('<svg class="w-5 h-5 text-gray-400" fill="currentColor" viewBox="0 0 20 20" role="img" aria-label="' + ERB::Util.html_escape(false_text) + '"><path fill-rule="evenodd" d="M10 18a8 8 0 100-16 8 8 0 000 16zM8.707 7.293a1 1 0 00-1.414 1.414L8.586 10l-1.293 1.293a1 1 0 101.414 1.414L10 11.414l1.293 1.293a1 1 0 001.414-1.414L11.414 10l1.293-1.293a1 1 0 00-1.414-1.414L10 8.586 8.707 7.293z" clip-rule="evenodd"/></svg>')
         end
       end
     end

data/lib/infotable/formatters/currency_formatter.rb

@@ -1,21 +1,13 @@
 module Infotable
   module Formatters
+    # formatter: :currency
+    #   formatter_options: { unit: "$", precision: 2, delimiter: ",", separator: "." }
+    # Options you leave out come from I18n (`number.currency.format`) for the current locale.
     class CurrencyFormatter < BaseFormatter
       def format(value, record, options = {})
         return "" if value.blank?
 
-        unit = options[:unit] || "$"
-        precision = options[:precision] || 2
-        delimiter = options[:delimiter] || ","
-        separator = options[:separator] || "."
-
-        number_to_currency(
-          value,
-          unit: unit,
-          precision: precision,
-          delimiter: delimiter,
-          separator: separator
-        )
+        number_to_currency(value, options.slice(:unit, :precision, :delimiter, :separator))
       end
     end
   end

data/lib/infotable/formatters/date_formatter.rb

@@ -10,16 +10,10 @@ module Infotable
         format = options[:format] || :default
 
         case format
-        when :short
-          value.strftime("%b %d, %Y")
-        when :long
-          value.strftime("%B %d, %Y")
-        when :time
-          value.strftime("%I:%M %p")
-        when :datetime
-          value.strftime("%b %d, %Y %I:%M %p")
+        when :short, :long, :time, :datetime
+          view_context.l(value, format: view_context.t("infotable.formatters.date.#{format}"))
         when :relative
-          time_ago_in_words(value)
+          view_context.content_tag(:span, time_ago_in_words(value), title: value.strftime("%Y-%m-%d %H:%M"))
         when :dot_date
           value.strftime("%d.%m.%Y")
         when :default

data/lib/infotable/formatters/duration_formatter.rb

@@ -0,0 +1,51 @@
+module Infotable
+  module Formatters
+    # formatter: :duration
+    # Seconds as "1h 05m" (:short, default) or "1 hour 5 minutes" (:long).
+    #   formatter_options: { format: :short, parts: 2 }   # parts: how many units to show, from the largest
+    class DurationFormatter < BaseFormatter
+      UNITS = { d: 86_400, h: 3600, m: 60, s: 1 }.freeze
+
+      def format(value, record, options = {})
+        return "" if value.nil? || value == ""
+
+        seconds = Float(value.to_s, exception: false)
+        return value.to_s if seconds.nil? || seconds.negative?
+
+        parts = split(seconds.round).first(options.fetch(:parts, 2))
+        parts = [ [ :s, 0 ] ] if parts.empty?
+        options[:format].to_s == "long" ? long(parts) : short(parts)
+      end
+
+      private
+
+      # [[:h, 1], [:m, 5]]; units with nothing in them are left out
+      def split(seconds)
+        UNITS.filter_map do |unit, size|
+          count, seconds = seconds.divmod(size)
+          [ unit, count ] if count.positive?
+        end
+      end
+
+      def short(parts)
+        parts.each_with_index.map do |(unit, count), index|
+          number = index.zero? ? count.to_s : count.to_s.rjust(2, "0")
+          view_context.t("infotable.formatters.duration.short.#{unit}", count: number)
+        end.join(" ")
+      end
+
+      def long(parts)
+        parts.map { |unit, count| view_context.t("infotable.formatters.duration.long.#{unit}.#{plural_key(count)}", count: count) }.join(" ")
+      end
+
+      # The key is picked here, so Polish (1 / 2-4 / 5+) is right without rails-i18n's pluralization rules
+      def plural_key(count)
+        return count == 1 ? :one : :other unless I18n.locale.to_s == "pl"
+        return :one if count == 1
+        return :few if (2..4).cover?(count % 10) && !(12..14).cover?(count % 100)
+
+        :many
+      end
+    end
+  end
+end

data/lib/infotable/formatters/filesize_formatter.rb

@@ -0,0 +1,14 @@
+module Infotable
+  module Formatters
+    # formatter: :filesize
+    # Bytes as a human size: 1536 => "1.5 KB". `formatter_options: { precision: 2 }` (significant digits)
+    class FilesizeFormatter < BaseFormatter
+      def format(value, record, options = {})
+        return "" if value.nil? || value == ""
+        return value.to_s if Float(value.to_s, exception: false).nil?
+
+        view_context.number_to_human_size(value, precision: options.fetch(:precision, 2), strip_insignificant_zeros: true)
+      end
+    end
+  end
+end

data/lib/infotable/formatters/image_formatter.rb

@@ -0,0 +1,31 @@
+module Infotable
+  module Formatters
+    # formatter: :image
+    # A square thumbnail (use :avatar for round pictures); the value is the image URL.
+    #   formatter_options: {
+    #     size: :md,                        # :sm (32px), :md (48px), :lg (64px)
+    #     alt: ->(record) { record.name },  # alt text, a String or a Proc
+    #     link: true                        # open the full image in a new tab
+    #   }
+    class ImageFormatter < BaseFormatter
+      SIZES = { sm: "h-8 w-8", md: "h-12 w-12", lg: "h-16 w-16" }.freeze
+
+      def format(value, record, options = {})
+        return "" unless image_url?(value)
+
+        alt = options[:alt].is_a?(Proc) ? view_context.instance_exec(record, &options[:alt]) : options[:alt]
+        size = SIZES.fetch((options[:size] || :md).to_sym, SIZES[:md])
+        image = tag.img(src: value.to_s, alt: alt.to_s, loading: "lazy", class: "#{size} rounded-md object-cover flex-none")
+        return image unless options[:link]
+
+        link_to(image, value.to_s, target: "_blank", rel: "noopener noreferrer")
+      end
+
+      private
+
+      def image_url?(value)
+        LinkFormatter.safe_url?(value) && value.to_s.match?(%r{\A(https?:)?//|\A/})
+      end
+    end
+  end
+end

data/lib/infotable/formatters/number_formatter.rb

@@ -0,0 +1,46 @@
+module Infotable
+  module Formatters
+    # formatter: :number
+    #   formatter_options: {
+    #     precision: 2,       # decimals; without it the number is shown as it is
+    #     delimiter: ",",     # thousands separator, default ","
+    #     separator: ".",     # decimal separator, default "."
+    #     unit: "ms",         # appended after the number
+    #     compact: true,      # 1.2k, 3.4M, 5B (precision defaults to 1)
+    #     zero: "-"           # shown instead of 0
+    #   }
+    class NumberFormatter < BaseFormatter
+      COMPACT_STEPS = [ [ 1_000_000_000, "B" ], [ 1_000_000, "M" ], [ 1_000, "k" ] ].freeze
+
+      def format(value, record, options = {})
+        return "" if value.nil? || value == ""
+
+        number = Float(value.to_s, exception: false)
+        return value.to_s if number.nil?
+        return options[:zero].to_s if options.key?(:zero) && number.zero?
+
+        text = options[:compact] ? compact(value, number, options) : plain(value, options)
+        text = "#{text} #{options[:unit]}" if options[:unit].present?
+        content_tag(:span, text, class: "tabular-nums")
+      end
+
+      private
+
+      def plain(value, options)
+        delimiter = options.fetch(:delimiter, ",")
+        separator = options.fetch(:separator, ".")
+        return view_context.number_with_delimiter(value, delimiter: delimiter, separator: separator) unless options[:precision]
+
+        view_context.number_with_precision(value, precision: options[:precision], delimiter: delimiter, separator: separator)
+      end
+
+      def compact(value, number, options)
+        divisor, suffix = COMPACT_STEPS.find { |step, _| number.abs >= step }
+        return plain(value, options) unless divisor
+
+        view_context.number_with_precision(number / divisor, precision: options.fetch(:precision, 1),
+                                           separator: options.fetch(:separator, "."), strip_insignificant_zeros: true) + suffix
+      end
+    end
+  end
+end

data/lib/infotable/formatters/tags_formatter.rb

@@ -0,0 +1,44 @@
+module Infotable
+  module Formatters
+    # formatter: :tags (alias :list)
+    # The value is an Array, a relation or a comma separated string; every item becomes a small badge.
+    #   formatter_options: {
+    #     limit: 3,                        # show this many, then "+N" (the rest is in its tooltip)
+    #     label: ->(item) { item.name },   # text of an item, defaults to item.to_s
+    #     colors: { "admin" => "red" },    # item => badge colour, as in :badge (default gray)
+    #     separator: ", "                  # plain text joined with this instead of badges
+    #   }
+    class TagsFormatter < BaseFormatter
+      def format(value, record, options = {})
+        labels = items(value).map { label_for(_1, options) }.reject(&:blank?)
+        return "" if labels.empty?
+
+        return safe_join(labels, options[:separator].to_s) if options[:separator]
+
+        limit = options[:limit]
+        shown, rest = limit ? [ labels.first(limit), labels.drop(limit) ] : [ labels, [] ]
+        badges = shown.map { badge(_1, options) }
+        badges << content_tag(:span, "+#{rest.size}", title: rest.join(", "), class: "text-xs text-gray-500 dark:text-gray-400") if rest.any?
+        content_tag(:div, safe_join(badges), class: "flex flex-wrap items-center gap-1")
+      end
+
+      private
+
+      def items(value)
+        return [] if value.nil?
+        return value.split(",").map(&:strip) if value.is_a?(String)
+
+        value.respond_to?(:to_a) ? value.to_a : [ value ]
+      end
+
+      def label_for(item, options)
+        label = options[:label].is_a?(Proc) ? view_context.instance_exec(item, &options[:label]) : item
+        label.to_s
+      end
+
+      def badge(text, options)
+        BadgeFormatter.new(view_context).format(text, nil, label: text, size: :small, colors: options[:colors])
+      end
+    end
+  end
+end

data/lib/infotable/formatters/truncate_formatter.rb

@@ -0,0 +1,19 @@
+module Infotable
+  module Formatters
+    # formatter: :truncate
+    # Long text cut to `length` characters; the full text stays in the cell's tooltip.
+    #   formatter_options: { length: 60, omission: "…" }
+    class TruncateFormatter < BaseFormatter
+      def format(value, record, options = {})
+        return "" if value.blank?
+
+        text = value.to_s
+        length = options.fetch(:length, 60)
+        return text if text.length <= length
+
+        shortened = view_context.truncate(text, length: length, omission: options.fetch(:omission, "…"))
+        content_tag(:span, shortened, title: text)
+      end
+    end
+  end
+end

data/lib/infotable/mcp/introspection.rb

@@ -0,0 +1,94 @@
+require "generators/infotable/table/table_generator"
+
+module Infotable
+  module Mcp
+    # What the host app looks like: models and their columns, tables that exist, the DSL of this gem version.
+    module Introspection
+      module_function
+
+      def models
+        Rails.application.eager_load!
+        ActiveRecord::Base.descendants.reject { _1.abstract_class? || _1.name.nil? || !_1.table_exists? }.sort_by(&:name).map { describe_model(_1) }
+      end
+
+      def describe_model(model)
+        {
+          name: model.name,
+          table: model.table_name,
+          columns: model.columns.to_h { [ _1.name, _1.type.to_s ] },
+          enums: model.defined_enums.transform_values(&:keys),
+          associations: model.reflect_on_all_associations.map { { name: _1.name, kind: _1.macro, model: _1.options[:class_name] || _1.name.to_s.classify } }
+        }
+      end
+
+      def tables
+        Rails.application.eager_load!
+        Infotable::Base.descendants.reject { _1.name.nil? }.sort_by(&:name).map { describe_table(_1) }
+      end
+
+      def describe_table(table)
+        {
+          class: table.name,
+          model: (table.base_query.model.name rescue nil),
+          columns: table.columns.map { |col| col.slice(:name, :type, :sortable, :searchable, :filterable, :filter_type, :visible, :pinned).compact },
+          per_page: table.pagination_settings[:per_page],
+          default_sort: table.sort_settings.presence,
+          toolbar: table.toolbar_mode,
+          batch_actions: table.batch_action_list.map { _1[:name] },
+          row_click: table.row_click?,
+          infinite_scroll: table.infinite_scroll_enabled?,
+          countless: table.countless?,
+          no_authorize_block: table.table_authorize.nil?
+        }
+      end
+
+      # The DSL as this gem version knows it, read from the code so it cannot drift from the docs
+      def dsl
+        {
+          version: Infotable::VERSION,
+          column_options: Infotable::Base::COLUMN_OPTIONS,
+          column_types: Infotable::Generators::TableGenerator::TYPE_MAP.values.map { _1[:type] }.uniq + %i[badge currency percent link avatar action],
+          filter_types: %i[text boolean number date select],
+          formatters: Infotable::Formatters.built_in.keys,
+          toolbar_modes: %i[header rail],
+          table_settings: %i[query query_sql per_page per_page_options default_sort infinite_scroll countless url_state resizable_columns
+                             toolbar row_click row_link row_class row_data row_size checkbox_column batch_actions authorize export_columns
+                             table_title table_subtitle table_height nil_value empty_value],
+          batch_action_options: { required: %i[url], optional: %i[label method confirm color], methods: Infotable::BatchActions::METHODS, colors: Infotable::BatchActions::COLORS },
+          generate_table_options: Infotable::Generators::TableGenerator.class_options.keys
+        }
+      end
+
+      # Questions to put to the user before generating a table, each with a default proposed from the model
+      def table_options(model_name)
+        model = model_name.to_s.safe_constantize
+        return nil unless model.is_a?(Class) && model < ActiveRecord::Base
+
+        columns = model.column_names.reject { Infotable::Generators::TableGenerator::SENSITIVE.match?(_1) }
+        enums = model.defined_enums.keys
+        sort = columns.include?("created_at") ? "created_at:desc" : "#{model.primary_key}:asc"
+        belongs_to = model.reflect_on_all_associations(:belongs_to).map(&:name)
+
+        {
+          model: model.name,
+          notes: [
+            ("enum columns (#{enums.join(', ')}) become badges with a select filter" if enums.any?),
+            ("belongs_to #{belongs_to.join(', ')}: generated as a commented hint, a column needs a join" if belongs_to.any?),
+            "foreign keys and sensitive columns (password, token...) are left out"
+          ].compact,
+          questions: [
+            { param: "only", ask: "Which columns?", choices: columns, default: "all of the choices" },
+            { param: "sort", ask: "Default sort (column:direction)?", choices: columns, default: sort },
+            { param: "per_page", ask: "Rows per page?", choices: [ 10, 25, 50, 100 ], default: 25 },
+            { param: "toolbar", ask: "Toolbar: header bar or slim rail?", choices: %w[header rail], default: "header" },
+            { param: "checkbox", ask: "Row selection column?", default: false },
+            { param: "row_click", ask: "Clicking a row opens it (needs row_link)?", default: false },
+            { param: "infinite_scroll", ask: "Infinite scroll instead of pages?", default: false },
+            { param: "countless", ask: "Skip the total count (tables over ~1M rows)?", default: false },
+            { param: "authorize", ask: "Who may see the table? A Ruby expression over `controller`", default: "controller.current_user.present?" }
+          ]
+        }
+      end
+    end
+  end
+end

data/lib/infotable/mcp/server.rb

@@ -0,0 +1,26 @@
+module Infotable
+  module Mcp
+    module Server
+      TOOLS = [ ListModels, ListTables, DescribeDsl, TableOptions, GenerateTable, ValidateTable ].freeze
+
+      module_function
+
+      def build
+        readme = ::MCP::Resource.new(uri: "infotable://readme", name: "infotable-readme", title: "InfoTable README",
+                                     description: "Full documentation of the table DSL", mime_type: "text/markdown")
+        server = ::MCP::Server.new(
+          name: "infotable", version: Infotable::VERSION, tools: TOOLS, prompts: [ NewTablePrompt ], resources: [ readme ],
+          instructions: "Creates InfoTable tables in this Rails app. Start with list_models and table_options; ask the user for the settings before generate_table."
+        )
+        server.resources_read_handler do |params|
+          [ { uri: params[:uri], mimeType: "text/markdown", text: File.read(Infotable.root.join("README.md")) } ]
+        end
+        server
+      end
+
+      def run
+        ::MCP::Server::Transports::StdioTransport.new(build).open
+      end
+    end
+  end
+end

data/lib/infotable/mcp/table_checker.rb

@@ -0,0 +1,80 @@
+module Infotable
+  module Mcp
+    # Loads a table and looks for mistakes before the app does: columns the model lacks,
+    # a default sort on a missing column, a query that raises. Optionally returns a few rows.
+    class TableChecker
+      def initialize(name: nil, source: nil, preview: 0)
+        @name = name
+        @source = source
+        @preview = preview.to_i.clamp(0, 20)
+      end
+
+      def call
+        table = load_table
+        problems = []
+        model = nil
+
+        begin
+          model = table.base_query.model
+        rescue StandardError => e
+          return { ok: false, problems: [ "query raises #{e.class}: #{e.message}" ] }
+        end
+
+        problems.concat(column_problems(table, model))
+        problems.concat(sort_problems(table))
+        problems << "no authorize block: anyone who can reach the engine routes can read this table" if table.table_authorize.nil?
+
+        rows = preview_rows(table, problems)
+        { ok: problems.none? { !_1.start_with?("no authorize") }, table: table.name, model: model.name, problems: problems, preview: rows }.compact
+      end
+
+      private
+
+      def load_table
+        if @source
+          mod = Module.new
+          mod.module_eval(@source.sub(/class \S+ </, "class CheckedTable <"), "infotable_mcp_check.rb")
+          mod.const_get(:CheckedTable)
+        else
+          reload_app
+          Infotable::TableResolver.resolve(@name)
+        end
+      end
+
+      # A table written a moment ago is not known to the autoloader yet
+      def reload_app
+        Rails.application.reloader.reload! if Rails.application.config.enable_reloading
+      rescue StandardError
+        nil
+      end
+
+      def column_problems(table, model)
+        table.columns.filter_map do |col|
+          next if col[:value] || col[:virtual] || col[:sql] || %i[action actions].include?(col[:type])
+          next if model.column_names.include?(col[:name].to_s) || model.method_defined?(col[:name])
+
+          "column :#{col[:name]} is not an attribute of #{model.name}: add value:, sql: or virtual:"
+        end
+      end
+
+      def sort_problems(table)
+        column = table.sort_settings[:column]
+        return [] if column.nil? || table.columns.any? { _1[:name].to_s == column.to_s }
+
+        [ "default_sort :#{column} is not a defined column" ]
+      end
+
+      def preview_rows(table, problems)
+        return nil if @preview.zero?
+
+        columns = table.visible_columns.reject { %i[action actions].include?(_1[:type]) }
+        table.base_query.limit(@preview).map do |record|
+          columns.to_h { |col| [ col[:name], table.cell_value(record, col).to_s ] }
+        end
+      rescue StandardError => e
+        problems << "query raises #{e.class}: #{e.message}"
+        nil
+      end
+    end
+  end
+end