mensa 0.6.11 → 0.6.12

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 595e1c13d2966b2cf3991e4f145bf408655431ca50a388d47c5fc8532d534635
-  data.tar.gz: 06a44600cbf0f6cdf14f0cdc8dfd3e4cb31ca0749b0cfbbb9017295bcea6ec9a
+  metadata.gz: 72a11ca0b316e616b3705f54523e4fe6f6ae408f7e767f9a130db02d1afc088f
+  data.tar.gz: ae13275d6ead1adece9e27ea3f82143c3dc88bb1aa7f443ad8aaf8dca251eff1
 SHA512:
-  metadata.gz: 7873d0830a89a852aae065431b35312ab71d00284330bf6b20a7aacf64250f3480c28478955a86b6c5e90b2882be7d1de3d3df1ab3e0a8ee16e04834ddb9f258
-  data.tar.gz: f50ca9748a2fe082d257d79339f2408bd36dfca6bbd4dda32b184fefc5beee6570280eb1f289028d4c36ed7586a5cd6f56d80b87476992800621a68cdaa67adf
+  metadata.gz: 1a5f0d0e105762e8542af697c8bc1af5816ac2d628b9ba1e22bab262828ddf47ffbfe5e8f8a9d03ca78990caa8cf6b313748199eaa2f2eae0658cf6a2ad0c8f0
+  data.tar.gz: 8ba1ab12c0c48b03f4b425cc933614bbc5880fed150fbf70f2e32e39dd90307eca0a530c2cf43e81450708ba094fcab9dfe6dd81258b2cb77a72818f4f48fed9

data/.shipkit.yml

@@ -0,0 +1,2 @@
+---
+previous_version: 0.6.11

data/CHANGELOG.md

@@ -1,5 +1,23 @@
 # Changelog
 
+## 0.6.12
+
+- Tables built with `params` (`table :name, params: {...}`) now work in filters,
+  views, batch actions and exports. The params are sent to these endpoints as
+  `params[...]` query parameters and stored on `Mensa::Export#config`, so
+  `Mensa::ExportJob` (and recurring exports) rebuild the table with them.
+  Host apps can remove their FiltersController, ExportsController and
+  Table::Component patches for this.
+- The export list, badge and Turbo stream are scoped per table params, so
+  exports of e.g. two different queries on the same table are no longer mixed.
+- Browser state (filters, search, order, column order, hidden columns) is
+  stored per table params. Unknown column names in `column_order`,
+  `hidden_columns`, `order` and `filters` are ignored instead of raising.
+- The export completed callback is now `export_completed`, as documented in the
+  generated initializer. The old `export_complete` name still works. Unknown
+  callback names are logged as a warning.
+- `selected_scope` only selects `id` when the relation has an `id` column.
+
 ## 0.2.4
 
 - Renames the data column on table_views to config

data/Gemfile

@@ -22,3 +22,7 @@ group :development, :test do
   gem "ruby-lsp", require: false
   gem "ruby-lsp-rails", require: false
 end
+
+source "https://rubygems.pkg.github.com/entdec" do
+  gem "shipkit"
+end

data/Gemfile.lock

@@ -1,7 +1,7 @@
 PATH
   remote: .
   specs:
-    mensa (0.6.10)
+    mensa (0.6.11)
       csv
       importmap-rails
       pagy (>= 43)
@@ -366,6 +366,11 @@ GEM
     yaml (0.4.0)
     zeitwerk (2.8.2)
 
+GEM
+  remote: https://rubygems.pkg.github.com/entdec/
+  specs:
+    shipkit (0.1.2)
+
 PLATFORMS
   aarch64-linux-gnu
   aarch64-linux-musl
@@ -391,8 +396,9 @@ DEPENDENCIES
   ruby-lsp
   ruby-lsp-rails
   selenium-webdriver (~> 4.17)
+  shipkit!
   sprockets-rails
   standard
 
 BUNDLED WITH
-   2.6.2
+   2.6.9

data/README.md

@@ -186,12 +186,44 @@ Next you can run the generator to generate a table:
 $ rails g mensa:table:generate <model_name>
 ```
 
+### Table params
+
+A table can be built with extra params, for example when its scope or columns
+depend on a record:
+
+```erb
+<%= table :query_results, params: {query_id: @query.id} %>
+```
+
+They are available as `params` inside the table (e.g. `params[:query_id]`) and
+are sent along whenever Mensa rebuilds the table: paging, filters, views, batch
+actions and exports (including recurring exports, which store them on the
+`Mensa::Export`). Exports and the state the browser remembers (filters, order,
+columns) are kept per table *and* params.
+
 ### Exports
 
 Exporting is built into the table's control bar. Clicking the export button opens
 a dialog that lists the user's previous downloads and lets them request a new
 export (scope and CSV format). 
 
+#### Export callbacks
+
+Configure callbacks in your Mensa initializer to act on exports, for example to
+email the user once their download is ready:
+
+```ruby
+Mensa.setup do |config|
+  config.callbacks = {
+    export_started: ->(export) {},
+    export_completed: ->(export) { ExportMailer.with(export: export).ready.deliver_later }
+  }
+end
+```
+
+`export_completed` was called `export_complete` before 0.6.12; that name still
+works. Unknown callback names are logged as a warning.
+
 #### Repeating exports
 
 The user can choose to export a table on a regular basis (daily, weekly, monthly, quarterly, bi-yearly, yearly).

data/app/components/mensa/column_customizer/component.html.erb

@@ -1,6 +1,7 @@
 <div class="relative"
      data-controller="mensa-column-customizer"
      data-mensa-column-customizer-table-name-value="<%= table.name %>"
+     data-mensa-column-customizer-storage-key-value="<%= table.storage_key %>"
      data-mensa-column-customizer-turbo-frame-id-value="<%= table.table_id %>"
      data-mensa-column-customizer-mensa-table-outlet="#table-<%= table.table_id %>">
   <button class="mensa-table__control_bar__button" type="button" data-action="click->mensa-column-customizer#toggle">

data/app/components/mensa/column_customizer/component_controller.js

@@ -3,7 +3,7 @@ import ApplicationController from "mensa/controllers/application_controller";
 export default class ColumnCustomizerController extends ApplicationController {
     static outlets = ["mensa-table"];
     static targets = ["popover", "columnRow"];
-    static values = { turboFrameId: String, tableName: String };
+    static values = { turboFrameId: String, tableName: String, storageKey: String };
 
     connect() {
         super.connect();
@@ -340,12 +340,17 @@ export default class ColumnCustomizerController extends ApplicationController {
         if (view) url.searchParams.set("table_view_id", view);
     }
 
+    // Tables built with different params keep separate browser state.
+    get storageName() {
+        return this.storageKeyValue || this.tableNameValue;
+    }
+
     get _columnOrderKey() {
-        return `mensa:column_order:${this.tableNameValue}`;
+        return `mensa:column_order:${this.storageName}`;
     }
 
     get _hiddenColumnsKey() {
-        return `mensa:hidden_columns:${this.tableNameValue}`;
+        return `mensa:hidden_columns:${this.storageName}`;
     }
 
     _writeStorage(key, value) {

data/app/components/mensa/control_bar/component.html.erb

@@ -45,13 +45,13 @@
     <% if table.exportable? %>
       <button class="mensa-table__control_bar__button relative" type="button" data-action="mensa-table#export">
         <i data-mensa-table-target="exportIcon" class="<%= Mensa.config.icons[:control_bar_export] %>"></i>
-        <%= helpers.render partial: "mensa/exports/badge", locals: {table_name: table.name, user: table.current_user} %>
+        <%= helpers.render partial: "mensa/exports/badge", locals: {table_name: table.name, user: table.current_user, table_params: table.params} %>
       </button>
     <% end %>
   </div>
 
   <% if table.exportable? %>
-    <%= helpers.turbo_stream_from Mensa::Export.stream_name(table.name, table.current_user) %>
+    <%= helpers.turbo_stream_from Mensa::Export.stream_name(table.name, table.current_user, params: table.params) %>
     <%= helpers.render partial: "mensa/exports/dialog", locals: {table: table} %>
   <% end %>
 </div>

data/app/components/mensa/filter_pill_list/component.html.erb

@@ -4,6 +4,7 @@
      data-controller="mensa-filter-pill-list"
      data-mensa-table-target="filterList"
      data-mensa-filter-pill-list-table-name-value="<%= table.name %>"
+     data-mensa-filter-pill-list-storage-key-value="<%= table.storage_key %>"
      data-mensa-filter-pill-list-mensa-table-outlet=".mensa-table#table-<%= table.table_id %>"
      data-mensa-filter-pill-list-mensa-filter-pill-outlet=".mensa-filter-pill"
      data-mensa-filter-pill-list-mensa-add-filter-outlet="[data-controller=mensa-add-filter]">

data/app/components/mensa/filter_pill_list/component_controller.js

@@ -8,6 +8,7 @@ export default class FilterPillListComponentController extends ApplicationContro
     static values = {
         supportsViews: Boolean,
         tableName: String,
+        storageKey: String,
     };
 
     connect() {
@@ -567,8 +568,8 @@ export default class FilterPillListComponentController extends ApplicationContro
         this.writeStorage(this.filtersStorageKey, null);
         this.writeStorage(this.searchStorageKey, null);
         this.writeStorage(this.orderStorageKey, null);
-        this.writeStorage(`mensa:column_order:${this.tableNameValue}`, null);
-        this.writeStorage(`mensa:hidden_columns:${this.tableNameValue}`, null);
+        this.writeStorage(`mensa:column_order:${this.storageName}`, null);
+        this.writeStorage(`mensa:hidden_columns:${this.storageName}`, null);
     }
 
     // Keep these for backward-compatibility with other controllers that look up
@@ -698,7 +699,7 @@ export default class FilterPillListComponentController extends ApplicationContro
             return (
                 JSON.parse(
                     this.readStorage(
-                        `mensa:column_order:${this.tableNameValue}`,
+                        `mensa:column_order:${this.storageName}`,
                     ),
                 ) || []
             );
@@ -712,7 +713,7 @@ export default class FilterPillListComponentController extends ApplicationContro
             return (
                 JSON.parse(
                     this.readStorage(
-                        `mensa:hidden_columns:${this.tableNameValue}`,
+                        `mensa:hidden_columns:${this.storageName}`,
                     ),
                 ) || []
             );
@@ -721,20 +722,25 @@ export default class FilterPillListComponentController extends ApplicationContro
         }
     }
 
+    // Tables built with different params keep separate browser state.
+    get storageName() {
+        return this.storageKeyValue || this.tableNameValue;
+    }
+
     get filtersStorageKey() {
-        return `mensa:filters:${this.tableNameValue}`;
+        return `mensa:filters:${this.storageName}`;
     }
     get searchStorageKey() {
-        return `mensa:search:${this.tableNameValue}`;
+        return `mensa:search:${this.storageName}`;
     }
     get viewStorageKey() {
-        return `mensa:view:${this.tableNameValue}`;
+        return `mensa:view:${this.storageName}`;
     }
     get pageStorageKey() {
-        return `mensa:page:${this.tableNameValue}`;
+        return `mensa:page:${this.storageName}`;
     }
     get orderStorageKey() {
-        return `mensa:order:${this.tableNameValue}`;
+        return `mensa:order:${this.storageName}`;
     }
 
     get ourUrl() {

data/app/components/mensa/table/component.html.erb

@@ -2,9 +2,9 @@
      id="table-<%= table.table_id %>"
      data-mensa-table-supports-views-value="<%= table.views? %>"
      data-mensa-table-table-url-value="<%= table.path(turbo_frame_id: table.table_id, user_params: params) %>"
-     data-mensa-table-save-view-url-value="<%= helpers.mensa.table_views_path(table.name) %>"
-     data-mensa-table-views-url-value="<%= helpers.mensa.table_views_path(table.name) %>"
-     data-mensa-table-exports-url-value="<%= helpers.mensa.table_exports_path(table.name) %>"
+     data-mensa-table-save-view-url-value="<%= table.path_with_params(helpers.mensa.table_views_path(table.name)) %>"
+     data-mensa-table-views-url-value="<%= table.path_with_params(helpers.mensa.table_views_path(table.name)) %>"
+     data-mensa-table-exports-url-value="<%= table.path_with_params(helpers.mensa.table_exports_path(table.name)) %>"
      data-controller="mensa-table"
      data-action="click@document->mensa-table#saveDropdownOutsideHandler"
      data-mensa-table-mensa-filter-pill-outlet="[data-controller='mensa-filter-pill']"

data/app/components/mensa/table/component_controller.js

@@ -255,7 +255,7 @@ export default class TableComponentController extends ApplicationController {
         const state = this.currentViewState();
         this.hideSaveReset();
 
-        const response = await patch(`${this.saveViewUrlValue}/${viewId}`, {
+        const response = await patch(this.memberUrl(this.saveViewUrlValue, viewId), {
             body: JSON.stringify({
                 query: state.query,
                 filters: state.filters,
@@ -439,17 +439,21 @@ export default class TableComponentController extends ApplicationController {
     // --- View filter visibility persistence ---
 
     _viewFiltersStorageKey() {
-        return `mensa:view-filters-visible:${this._tableName()}`;
+        return `mensa:view-filters-visible:${this._storageName()}`;
     }
 
-    _tableName() {
+    _storageName() {
         if (this.hasMensaFilterPillListOutlet) {
-            return this.mensaFilterPillListOutlet.tableNameValue;
+            return this.mensaFilterPillListOutlet.storageName;
         }
         const el = this.element.querySelector(
             "[data-mensa-filter-pill-list-table-name-value]",
         );
-        return el?.dataset?.mensaFilterPillListTableNameValue || "";
+        return (
+            el?.dataset?.mensaFilterPillListStorageKeyValue ||
+            el?.dataset?.mensaFilterPillListTableNameValue ||
+            ""
+        );
     }
 
     _loadViewFiltersVisible() {

data/app/components/mensa/view/component.html.erb

@@ -2,7 +2,7 @@
   <div class="overflow-y-auto relative"
        data-mensa-table-target="scrollContainer"
        data-controller="mensa-selection"
-       data-mensa-selection-batch-url-value="<%= table.batch_actions? ? helpers.mensa.table_batch_actions_path(table.name) : "" %>">
+       data-mensa-selection-batch-url-value="<%= table.batch_actions? ? table.path_with_params(helpers.mensa.table_batch_actions_path(table.name)) : "" %>">
     <% if table.batch_actions? %>
       <div class="mensa-batch-bar hidden" data-mensa-selection-target="batchBar">
         <div class="mensa-batch-bar__content">

data/app/components/mensa/views/component.html.erb

@@ -8,7 +8,7 @@
      data-controller="mensa-views"
      data-mensa-views-mensa-filter-pill-list-outlet="#mensa-filter-pill-list-<%= table.table_id %>"
      data-mensa-views-table-id-value="<%= table.table_id %>"
-     data-mensa-views-views-url-value="<%= helpers.mensa.table_views_path(table.name) %>">
+     data-mensa-views-views-url-value="<%= table.path_with_params(helpers.mensa.table_views_path(table.name)) %>">
   <button class="mensa-table__views__trigger" type="button" data-action="mensa-views#toggleDropdown" data-mensa-views-target="trigger" aria-haspopup="listbox">
     <span class="mensa-table__views__trigger-label" data-mensa-views-target="triggerLabel"><%= current_view_name %></span>
     <i class="<%= Mensa.config.icons[:views_trigger] %> mensa-table__views__trigger-icon"></i>

data/app/components/mensa/views/component_controller.js

@@ -120,7 +120,7 @@ export default class ViewsComponentController extends ApplicationController {
         }
 
         const turboFrameId = this._turboFrameId();
-        const response = await patch(`${this.viewsUrlValue}/${viewId}`, {
+        const response = await patch(this.memberUrl(this.viewsUrlValue, viewId), {
             body: JSON.stringify({ name: newName, turbo_frame_id: turboFrameId }),
             contentType: "application/json",
             responseKind: "turbo-stream",
@@ -177,7 +177,7 @@ export default class ViewsComponentController extends ApplicationController {
         if (!confirm(`Delete "${viewName}"?`)) return;
 
         const turboFrameId = this._turboFrameId();
-        await destroy(`${this.viewsUrlValue}/${viewId}`, {
+        await destroy(this.memberUrl(this.viewsUrlValue, viewId), {
             body: JSON.stringify({ turbo_frame_id: turboFrameId }),
             contentType: "application/json",
             responseKind: "turbo-stream",

data/app/controllers/mensa/tables/batch_actions_controller.rb

@@ -8,7 +8,7 @@ module Mensa
         batch_action_name = params[:batch_action_name]&.to_sym
         record_ids = Array(params[:record_ids])
 
-        table = Mensa.for_name(table_name)
+        table = Mensa.for_name(table_name, params: Mensa::TableParams.from_request(params))
         table.original_view_context = helpers
 
         batch_action = table.batch_actions.find { |a| a.name == batch_action_name }

data/app/controllers/mensa/tables/exports_controller.rb

@@ -4,6 +4,10 @@ module Mensa
     # requests. Generating the CSV happens asynchronously in Mensa::ExportJob;
     # both the export button badge and the downloads list are refreshed via
     # Turbo streams once the job completes.
+    #
+    # Tables built with extra params send them along as params[...] in the
+    # exports URL. They are stored on the export so Mensa::ExportJob can
+    # rebuild the table, and they scope the downloads list and badge.
     class ExportsController < ::ApplicationController
       # Returns the current downloads list for the table, used to refresh the
       # contents of the export dialog when it is opened.
@@ -46,9 +50,10 @@ module Mensa
       # Deletes an export from the current user's download list. The attached
       # asset is purged automatically when the record is destroyed.
       def destroy
-        export = exports.find(params[:id])
+        export = user_exports.find(params[:id])
+        @table_params = export.table_params
         export.destroy
-        Mensa::Export.broadcast_refresh(export.table_name, export.user)
+        Mensa::Export.broadcast_refresh(export.table_name, export.user, params: export.table_params)
 
         respond_to do |format|
           format.turbo_stream { render turbo_stream: [list_stream, badge_stream] }
@@ -62,7 +67,7 @@ module Mensa
       # controller (instead of a direct Active Storage link) gives us a hook to
       # delete the Mensa::Export record and free the stored file afterwards.
       def download
-        export = exports.find(params[:id])
+        export = user_exports.find(params[:id])
         return head :not_found unless export.downloadable?
 
         data = export.asset.download
@@ -77,11 +82,10 @@ module Mensa
         begin
           if export.repeating?
             export.asset.purge_later
-            Mensa::Export.broadcast_refresh(export.table_name, export.user)
           else
             export.destroy
-            Mensa::Export.broadcast_refresh(export.table_name, export.user)
           end
+          Mensa::Export.broadcast_refresh(export.table_name, export.user, params: export.table_params)
         rescue => e
           Mensa.config.logger&.warn("Mensa::Export cleanup failed for #{export.id}: #{e.class}: #{e.message}")
         end
@@ -89,35 +93,50 @@ module Mensa
 
       private
 
+      # All of the current user's exports of this table, regardless of
+      # params. Download and delete links don't carry the params.
+      def user_exports
+        Mensa::Export.where(table_name: params[:table_id]).for_user(current_mensa_user)
+      end
+
+      # The exports listed for the table as built with the current params.
       def exports
-        @exports ||= Mensa::Export.for_table(params[:table_id]).for_user(current_mensa_user).recent
+        @exports ||= Mensa::Export.for_table(params[:table_id], params: table_params).for_user(current_mensa_user).recent
+      end
+
+      def table_params
+        @table_params ||= Mensa::TableParams.from_request(params)
       end
 
       def list_stream
-        turbo_stream.replace(Mensa::Export.list_dom_id(params[:table_id], current_mensa_user),
+        turbo_stream.replace(Mensa::Export.list_dom_id(params[:table_id], current_mensa_user, params: table_params),
           partial: "mensa/exports/list", locals: list_locals)
       end
 
       def badge_stream
-        turbo_stream.replace(Mensa::Export.badge_dom_id(params[:table_id], current_mensa_user),
+        turbo_stream.replace(Mensa::Export.badge_dom_id(params[:table_id], current_mensa_user, params: table_params),
           partial: "mensa/exports/badge",
-          locals: {table_name: params[:table_id], user: current_mensa_user})
+          locals: {table_name: params[:table_id], user: current_mensa_user, table_params: table_params})
       end
 
       def list_locals
-        {table_name: params[:table_id], user: current_mensa_user, exports: exports}
+        {table_name: params[:table_id], user: current_mensa_user, table_params: table_params, exports: exports}
       end
 
       def export_config
-        params.permit(
+        config = params.permit(
           :query,
           :page,
           :table_view_id,
           order: {},
           filters: {},
           column_order: [],
-          hidden_columns: []
+          hidden_columns: [],
+          params: {}
         ).to_h
+        config.delete(:params)
+        config[:params] = table_params if table_params.present?
+        config
       end
 
       def current_mensa_user

data/app/controllers/mensa/tables/filters_controller.rb

@@ -10,13 +10,13 @@ module Mensa
       end
 
       def index
-        config = {}.merge(params.permit(:id, :page, :table_id, :target, :table_view_id, :turbo_frame_id, order: {}, filters: {}).to_h)
+        config = {}.merge(params.permit(:id, :page, :table_id, :target, :table_view_id, :turbo_frame_id, order: {}, filters: {}, params: {}).to_h)
         @table = Mensa.for_name(params[:table_id], config)
       end
 
       # Returns the filter information on the column-name
       def show
-        config = {}.merge(params.permit(:id, :value, :operator, :page, :table_id, :target, :table_view_id, :turbo_frame_id, order: {}, filters: {}).to_h)
+        config = {}.merge(params.permit(:id, :value, :operator, :page, :table_id, :target, :table_view_id, :turbo_frame_id, order: {}, filters: {}, params: {}).to_h)
         @table = Mensa.for_name(params[:table_id], config)
         @table.original_view_context = helpers
         @column = @table.column(params[:id])

data/app/controllers/mensa/tables/views_controller.rb

@@ -24,7 +24,7 @@ module Mensa
               # generated element IDs match what is already in the DOM.
               table_config = view.config
                 .deep_transform_keys(&:to_sym)
-                .merge(turbo_frame_id: params[:turbo_frame_id])
+                .merge(turbo_frame_id: params[:turbo_frame_id], params: table_params)
 
               @table = Mensa.for_name(params[:table_id], table_config)
               @table.request = request
@@ -56,7 +56,7 @@ module Mensa
             format.turbo_stream do
               table_config = view.config
                 .deep_transform_keys(&:to_sym)
-                .merge(turbo_frame_id: params[:turbo_frame_id])
+                .merge(turbo_frame_id: params[:turbo_frame_id], params: table_params)
 
               @table = Mensa.for_name(params[:table_id], table_config)
               @table.request = request
@@ -81,7 +81,7 @@ module Mensa
 
         respond_to do |format|
           format.turbo_stream do
-            @table = Mensa.for_name(params[:table_id], {turbo_frame_id: params[:turbo_frame_id]})
+            @table = Mensa.for_name(params[:table_id], {turbo_frame_id: params[:turbo_frame_id], params: table_params})
             @table.request = request
             @table.original_view_context = helpers
           end
@@ -100,6 +100,11 @@ module Mensa
         config
       end
 
+      # The params the table was built with, sent along in the views URL.
+      def table_params
+        Mensa::TableParams.from_request(params)
+      end
+
       def current_mensa_user
         Current.user if defined?(Current) && Current.respond_to?(:user)
       end

data/app/javascript/mensa/controllers/application_controller.js

@@ -6,6 +6,14 @@ export default class ApplicationController extends Controller {
     this.element[this.identifier] = this
   }
 
+  // Appends a member id to a collection URL while keeping its query string
+  // (e.g. the table's params[...]) intact.
+  memberUrl(collectionUrl, id) {
+    const url = new URL(collectionUrl, window.location.origin)
+    url.pathname += `/${encodeURIComponent(id)}`
+    return url.toString()
+  }
+
   getController(element, identifier) {
     return this.application.getControllerForElementAndIdentifier(element, identifier)
   }

data/app/jobs/mensa/export_job.rb

@@ -13,7 +13,7 @@ module Mensa
       return unless export
 
       export.update(status: "processing")
-      Mensa.config.callbacks[:export_started]&.call(export)
+      Mensa.config.run_callback(:export_started, export)
 
       table = build_table(export)
       unless table.exportable?
@@ -27,7 +27,7 @@ module Mensa
       export.asset.attach(io: tempfile, filename: filename, content_type: content_type)
       finalize(export, status: "completed", filename: filename)
 
-      Mensa.config.callbacks[:export_complete]&.call(export)
+      Mensa.config.run_callback(:export_completed, export)
     rescue => e
       Mensa.config.logger&.error("Mensa::ExportJob failed for export #{export&.id}: #{e.class}: #{e.message}")
       finalize(export, status: "failed") if export
@@ -40,8 +40,8 @@ module Mensa
 
     # Rebuilds the table the export was requested for, layering the view
     # configuration (if any) underneath the captured request configuration
-    # (filters, query, ordering, page) so the generated data matches what the
-    # user saw when they requested the export.
+    # (params, filters, query, ordering, page) so the generated data matches
+    # what the user saw when they requested the export.
     def build_table(export)
       config = {}
 
@@ -131,7 +131,7 @@ module Mensa
       export.update(attributes)
       # Refresh the export button badge (download count) and the downloads list
       # inside the export dialog for everyone viewing this table.
-      Mensa::Export.broadcast_refresh(export.table_name, export.user)
+      Mensa::Export.broadcast_refresh(export.table_name, export.user, params: export.table_params)
     end
   end
 end

data/app/models/mensa/export.rb

@@ -16,7 +16,19 @@ module Mensa
     validates :status, inclusion: {in: STATUSES}
     validates :repeat, inclusion: {in: REPEATS}
 
-    scope :for_table, ->(table_name) { where(table_name: table_name.to_s) }
+    # Exports of a table built with the given params (see Mensa::TableParams).
+    # Exports of the same table with different params are kept apart.
+    scope :for_table, ->(table_name, params: nil) {
+      relation = where(table_name: table_name.to_s)
+      table_params = Mensa::TableParams.normalize(params)
+      config_params = "#{quoted_table_name}.config -> 'params'"
+
+      if table_params.blank?
+        relation.where("COALESCE(#{config_params}, '{}'::jsonb) = '{}'::jsonb")
+      else
+        relation.where("#{config_params} = ?::jsonb", table_params.to_json)
+      end
+    }
     scope :for_user, ->(user) { where(user_id: user.respond_to?(:id) ? user&.id : user) }
     scope :completed, -> { where(status: "completed") }
     scope :recent, -> { order(created_at: :desc) }
@@ -39,6 +51,11 @@ module Mensa
       status == "pending"
     end
 
+    # The params the table was built with when this export was requested.
+    def table_params
+      (config || {}).stringify_keys["params"].presence || {}
+    end
+
     def next_repeat_run_at(from: nil)
       return if repeat.blank?
 
@@ -92,51 +109,51 @@ module Mensa
       completed? && asset.attached?
     end
 
-    # Number of currently-downloadable exports for a table/user combination.
-    # This is the number rendered in the export button badge.
-    def self.completed_count(table_name, user)
-      for_table(table_name).for_user(user).with_downloadable_asset.count
+    # Number of currently-downloadable exports for a table/user/params
+    # combination. This is the number rendered in the export button badge.
+    def self.completed_count(table_name, user, params: nil)
+      for_table(table_name, params: params).for_user(user).with_downloadable_asset.count
     end
 
-    # A stable, page-independent key identifying the exports of a table/user
-    # combination, used for Turbo stream names and DOM ids so background jobs
-    # can target them after completion.
-    def self.token(table_name, user)
+    # A stable, page-independent key identifying the exports of a
+    # table/user/params combination, used for Turbo stream names and DOM ids
+    # so background jobs can target them after completion.
+    def self.token(table_name, user, params: nil)
       user_key = user.respond_to?(:id) ? user&.id : user
-      [table_name.to_s, user_key || "anonymous"].join("-").parameterize
+      [table_name.to_s, user_key || "anonymous", Mensa::TableParams.digest(params)].compact.join("-").parameterize
     end
 
-    def self.stream_name(table_name, user)
-      "mensa-exports-#{token(table_name, user)}"
+    def self.stream_name(table_name, user, params: nil)
+      "mensa-exports-#{token(table_name, user, params: params)}"
     end
 
-    def self.badge_dom_id(table_name, user)
-      "mensa-export-badge-#{token(table_name, user)}"
+    def self.badge_dom_id(table_name, user, params: nil)
+      "mensa-export-badge-#{token(table_name, user, params: params)}"
     end
 
-    def self.list_dom_id(table_name, user)
-      "mensa-export-list-#{token(table_name, user)}"
+    def self.list_dom_id(table_name, user, params: nil)
+      "mensa-export-list-#{token(table_name, user, params: params)}"
     end
 
     # Re-renders the export button badge and downloads list for everyone
-    # subscribed to this table/user's export stream. Best-effort: a missing
-    # Action Cable backend (or other broadcast failure) must never break the
-    # caller (job completion, download cleanup, ...).
-    def self.broadcast_refresh(table_name, user)
-      stream = stream_name(table_name, user)
+    # subscribed to this table/user/params export stream. Best-effort: a
+    # missing Action Cable backend (or other broadcast failure) must never
+    # break the caller (job completion, download cleanup, ...).
+    def self.broadcast_refresh(table_name, user, params: nil)
+      stream = stream_name(table_name, user, params: params)
 
       Turbo::StreamsChannel.broadcast_replace_to(
         stream,
-        target: badge_dom_id(table_name, user),
+        target: badge_dom_id(table_name, user, params: params),
         partial: "mensa/exports/badge",
-        locals: {table_name: table_name, user: user}
+        locals: {table_name: table_name, user: user, table_params: params}
       )
 
       Turbo::StreamsChannel.broadcast_replace_to(
         stream,
-        target: list_dom_id(table_name, user),
+        target: list_dom_id(table_name, user, params: params),
         partial: "mensa/exports/list",
-        locals: {table_name: table_name, user: user, exports: for_table(table_name).for_user(user).recent}
+        locals: {table_name: table_name, user: user, table_params: params, exports: for_table(table_name, params: params).for_user(user).recent}
       )
     rescue => e
       Mensa.config.logger&.warn("Mensa::Export broadcast failed: #{e.class}: #{e.message}")

data/app/tables/mensa/base.rb

@@ -25,9 +25,11 @@ module Mensa
       @params = (@config[:params].presence || {}).deep_symbolize_keys
       @config[:params] = @params
 
+      # Hidden columns can come from browser state saved for different params,
+      # so skip names that aren't columns of this table.
       current_hidden_columns&.each do |column_name|
         c = columns.find { |c| c.name == column_name.to_sym }
-        c.config[:visible] = false
+        c.config[:visible] = false if c
       end
     end
 
@@ -40,6 +42,12 @@ module Mensa
       # are absent from any URL-supplied column_order. Always append them so
       # that columns and selected_scope include their attributes.
       all_keys = (config[:columns]&.keys || []).map(&:to_sym)
+      # A column_order can come from browser state saved for different params
+      # (with different columns), so drop names that aren't columns here.
+      if all_keys.any?
+        order &= all_keys
+        order = all_keys if order.empty?
+      end
       internal_keys = all_keys.select { |key| config.dig(:columns, key, :internal) }
       (order | internal_keys)
     end
@@ -140,6 +148,18 @@ module Mensa
       query.present? ? "#{path}?#{query}" : path
     end
 
+    # Appends this table's params to a Mensa endpoint path, so the endpoint
+    # can rebuild the table (see Mensa::TableParams).
+    def path_with_params(path)
+      Mensa::TableParams.append_to(path, params)
+    end
+
+    # Key under which the browser persists this table's state (filters, order,
+    # column order, ...). Tables built with different params get separate state.
+    def storage_key
+      [name, Mensa::TableParams.digest(params)].compact.join(":")
+    end
+
     def all_views
       views = system_views
       views += TableView.where(table_name: name).where(user: [nil, current_user])

data/app/tables/mensa/column.rb

@@ -74,7 +74,7 @@ module Mensa
       @attribute_for_condition = if config[:attribute].present?
         Arel.sql(raw_attribute)
       elsif table.model.column_names.include? name.to_s
-        Arel.sql("\"#{table.model.table_name}\".\"#{name}\"")
+        Arel.sql("#{table.model.connection.quote_table_name(table.model.table_name)}.#{table.model.connection.quote_column_name(name)}")
       end
     end
 

data/app/tables/mensa/scope.rb

@@ -47,7 +47,7 @@ module Mensa
       ensure_internal_columns_for_joined_associations
 
       @selected_scope = ordered_scope
-      @selected_scope = @selected_scope.select([:id] + columns.filter_map(&:attribute))
+      @selected_scope = @selected_scope.select((id_column? ? [:id] : []) + columns.filter_map(&:attribute))
 
       @selected_scope
     end
@@ -76,6 +76,16 @@ module Mensa
 
     private
 
+    # Relations without an id column (e.g. a read-only model backed by a
+    # subquery) can't select it.
+    def id_column?
+      relation = ordered_scope
+      klass = relation.respond_to?(:klass) ? relation.klass : model
+      klass.column_names.include?("id")
+    rescue ActiveRecord::ActiveRecordError
+      false
+    end
+
     def adjacent_record(record, step:)
       records = ordered_scope.to_a
       index = records.find_index { |candidate| same_record?(candidate, record) }
@@ -110,11 +120,20 @@ module Mensa
       result = current_order_provided? ? (current_order || {}) : (config[:order] || {})
       result = result.symbolize_keys.compact_blank.transform_values(&:to_sym)
       result.filter_map { |k, v|
-        attribute = column(k)&.attribute_for_condition || k
+        col = column(k)
+        # Skip orders on unknown names, e.g. from browser state saved for
+        # different params.
+        next unless col || model_attribute?(k)
+
+        attribute = col&.attribute_for_condition || k
         "#{attribute} #{v} NULLS LAST"
       }.join(", ")
     end
 
+    def model_attribute?(name)
+      model.respond_to?(:column_names) && model.column_names.include?(name.to_s)
+    end
+
     # Builds an order hash for URL generation. Merges current order with overrides;
     # nil values become "" so they appear in the URL as order[col]= (which tells
     # the server the user explicitly cleared that column's sort direction).

data/app/tables/mensa/table_params.rb

@@ -0,0 +1,44 @@
+require "digest"
+
+module Mensa
+  # Helpers for the extra +params+ a table can be built with
+  # (`Mensa::Table::Component.new("name", params: {...})`). They travel to
+  # Mensa's endpoints as `params[...]` query parameters, the same way
+  # Mensa::Base#path sends them, so normalizing through that query-string
+  # round trip gives exactly the hash the controllers receive.
+  module TableParams
+    module_function
+
+    # Returns the params as a string-keyed hash with string values, or {} when
+    # blank. Accepts plain hashes and ActionController::Parameters.
+    def normalize(params)
+      params = params.to_unsafe_h if params.respond_to?(:to_unsafe_h)
+      return {} if params.blank?
+
+      Rack::Utils.parse_nested_query({params: params}.to_query)["params"] || {}
+    end
+
+    # The permitted `params` sent along with a request to a Mensa endpoint.
+    def from_request(request_params)
+      normalize(request_params.slice(:params).permit(params: {}).to_h[:params])
+    end
+
+    # Query string (`params[key]=value`) to append to Mensa endpoint URLs.
+    def to_query(params)
+      normalized = normalize(params)
+      normalized.present? ? {params: normalized}.to_query : ""
+    end
+
+    # Appends the params to +path+ as `params[...]` query parameters.
+    def append_to(path, params)
+      query = to_query(params)
+      query.present? ? "#{path}?#{query}" : path
+    end
+
+    # Short, stable digest identifying a set of params, or nil when blank.
+    def digest(params)
+      query = to_query(params)
+      Digest::SHA256.hexdigest(query)[0, 12] if query.present?
+    end
+  end
+end

data/app/views/mensa/exports/_badge.html.erb

@@ -1,5 +1,6 @@
-<% count = Mensa::Export.completed_count(table_name, user) %>
-<span id="<%= Mensa::Export.badge_dom_id(table_name, user) %>"
+<% table_params = local_assigns[:table_params] %>
+<% count = Mensa::Export.completed_count(table_name, user, params: table_params) %>
+<span id="<%= Mensa::Export.badge_dom_id(table_name, user, params: table_params) %>"
       class="mensa-table__control_bar__badge <%= 'hidden' unless count.positive? %>"
       aria-hidden="<%= count.positive? ? 'false' : 'true' %>">
   <%= count %>

data/app/views/mensa/exports/_dialog.html.erb

@@ -1,5 +1,5 @@
 <% user = table.current_user %>
-<% exports = Mensa::Export.for_table(table.name).for_user(user).recent %>
+<% exports = Mensa::Export.for_table(table.name, params: table.params).for_user(user).recent %>
 <dialog class="mensa-table__export-dialog" data-mensa-table-target="exportDialog" data-action="click->mensa-table#exportDialogBackdrop">
   <div class="mensa-table__export-dialog__panel">
     <header class="mensa-table__export-dialog__header">
@@ -10,7 +10,7 @@
     </header>
 
     <div class="mensa-table__export-dialog__body">
-      <%= render partial: "mensa/exports/list", locals: {table_name: table.name, user: user, exports: exports} %>
+      <%= render partial: "mensa/exports/list", locals: {table_name: table.name, user: user, table_params: table.params, exports: exports} %>
 
       <form class="mensa-table__export-dialog__form" data-action="submit->mensa-table#confirmExport">
         <fieldset class="mensa-table__export-dialog__fieldset">

data/app/views/mensa/exports/_list.html.erb

@@ -1,4 +1,4 @@
-<div id="<%= Mensa::Export.list_dom_id(table_name, user) %>" class="mensa-table__export-dialog__downloads">
+<div id="<%= Mensa::Export.list_dom_id(table_name, user, params: local_assigns[:table_params]) %>" class="mensa-table__export-dialog__downloads">
   <h3 class="mensa-table__export-dialog__section-title"><%= t("mensa.exports.available_downloads", default: "Available downloads") %></h3>
   <% if exports.blank? %>
     <p class="mensa-table__export-dialog__empty"><%= t("mensa.exports.empty", default: "You have no downloads yet. Create one below.") %></p>

data/lib/mensa/configuration.rb

@@ -120,15 +120,20 @@ module Mensa
       end,
       # Called with the Mensa::Export once the CSV has been generated and
       # attached (export.asset). Use this to e.g. notify or email the user.
+      # (Before 0.6.12 this was called export_complete; that name still works.)
       #
       # UserMailer.with(
       #   user: User.find(export.user_id),
       #   export: export,
       # ).export_email.deliver_later
-      export_complete: lambda do |export|
+      export_completed: lambda do |export|
       end
     }
 
+    CALLBACKS = %i[export_started export_completed].freeze
+    # Older names that are still called alongside the current one.
+    CALLBACK_ALIASES = {export_completed: %i[export_complete]}.freeze
+
     # :front or :back (default)
     option :row_actions_position, default: :back
     # It's either :basic or :fuzzy, for fuzzy search you need to have `pg_trgm` extension installed
@@ -137,6 +142,24 @@ module Mensa
     def initialize
       set_defaults!
     end
+
+    def callbacks=(callbacks)
+      known = CALLBACKS + CALLBACK_ALIASES.values.flatten
+      unknown = callbacks.to_h.keys.map(&:to_sym) - known
+      if unknown.any?
+        logger&.warn("Mensa: ignoring unknown callback(s) #{unknown.join(", ")}; known callbacks are #{CALLBACKS.join(", ")}")
+      end
+
+      @callbacks = callbacks
+    end
+
+    # Calls the callback registered under +name+ (or one of its older names).
+    def run_callback(name, *args)
+      [name, *CALLBACK_ALIASES.fetch(name, [])].each do |key|
+        callback = callbacks && (callbacks[key] || callbacks[key.to_s])
+        callback&.call(*args)
+      end
+    end
   end
 
   module Configurable

data/lib/mensa/version.rb

@@ -1,3 +1,3 @@
 module Mensa
-  VERSION = "0.6.11"
+  VERSION = "0.6.12"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: mensa
 version: !ruby/object:Gem::Version
-  version: 0.6.11
+  version: 0.6.12
 platform: ruby
 authors:
 - Tom de Grunt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-07-21 00:00:00.000000000 Z
+date: 2026-10-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -168,6 +168,7 @@ files:
 - ".gitignore"
 - ".prettierrc.json"
 - ".rubocop.yml"
+- ".shipkit.yml"
 - ".vscode/settings.json"
 - ".vscode/tasks.json"
 - ".zed/tasks.json"
@@ -277,6 +278,7 @@ files:
 - app/tables/mensa/scope.rb
 - app/tables/mensa/search.rb
 - app/tables/mensa/system_view.rb
+- app/tables/mensa/table_params.rb
 - app/views/mensa/exports/_badge.html.erb
 - app/views/mensa/exports/_dialog.html.erb
 - app/views/mensa/exports/_list.html.erb