basesite-shared-grid-lib 21.0.1-beta.7 → 21.0.1-beta.8

package/fesm2022/basesite-shared-grid-lib.mjs

@@ -317,7 +317,15 @@ class OdataProvider {
                         if (!col.values || col.values.length === 0) {
                             return '';
                         }
-                        const equalsClauses = col.values.map((v) => me.odataOperator.equalsStr(colName, `'${me.encode(v)}'`, isCaseSensitiveStringFilter));
+                        // Fill-cell / set-filter columns are always equality-matched against
+                        // a fixed list of backend-provided values, so the casing on both
+                        // sides is already known to match. Skip the tolower() wrap that the
+                        // generic string operators apply — wrapping the column in tolower()
+                        // forces a full scan because LOWER(col) cannot use any index, and
+                        // SQL Server's default collation is already case-insensitive.
+                        // Resulting predicate: `col eq 'Value'` (single) or
+                        // `(col eq 'V1' or col eq 'V2')` (multi).
+                        const equalsClauses = col.values.map((v) => me.odataOperator.equals(colName, `'${me.encode(v)}'`));
                         return equalsClauses.length === 1
                             ? equalsClauses[0]
                             : `(${equalsClauses.join(' or ')})`;
@@ -2423,8 +2431,11 @@ class GridLibraryComponent {
                         filterable: res.filterable,
                         filter: 'agSetColumnFilter',
                         filterParams: {
-                            // Provide the raw values from the backend config; OData provider
-                            // handles case-insensitive matching server-side via tolower().
+                            // Provide the raw values from the backend config exactly as
+                            // stored. The OData provider emits `(col eq 'Value')` for set
+                            // filters — no tolower() — and SQL Server's default collation
+                            // is case-insensitive, so casing on the wire just needs to
+                            // match what's in the column, not be normalized.
                             values: (params) => this._getFillFilterValues(res, params),
                             refreshValuesOnOpen: true,
                             // Open with nothing checked so a user picking one option triggers
@@ -2540,6 +2551,35 @@ class GridLibraryComponent {
             }
         });
     }
+    /**
+     * Derive the $select field list for OData requests from the configured
+     * column definitions. Includes every data-backed field but skips action
+     * columns (buttons, action dropdowns) whose `field` isn't a real entity
+     * property. Deduped so a field declared twice — e.g. for both display and
+     * tooltip — only appears once in the select clause.
+     */
+    _getServerSelectFields() {
+        const source = (this.initialColumnDef && this.initialColumnDef.length > 0)
+            ? this.initialColumnDef
+            : (this.columnDefs || []);
+        const fields = new Set();
+        for (const res of source) {
+            if (!res)
+                continue;
+            // Skip action buttons — their `field` is usually a label slot, not a
+            // backing entity property, and OData will 400 on unknown properties.
+            if (res.isButton === true)
+                continue;
+            // Skip action dropdowns (e.g. "Create/View DAC") for the same reason.
+            if (res.columnType === 'dropdown')
+                continue;
+            const field = res.field;
+            if (typeof field === 'string' && field.length > 0) {
+                fields.add(field);
+            }
+        }
+        return Array.from(fields);
+    }
     _getFillFilterValues(res, params) {
         const configured = res?.filterValues;
         if (Array.isArray(configured) && configured.length > 0) {
@@ -2746,17 +2786,20 @@ class GridLibraryComponent {
             // Add timeout to prevent infinite loading
             const API_TIMEOUT = 800000; //80 seconds
             let hasRetried = false;
-            // Fill-cell columns use the set filter, which only emits exact-match
-            // predicates (eq / in). Wrapping those in tolower() forces the DB to
-            // scan + lowercase every row (non-sargable), which was making filter
-            // requests ~10x+ slower than baseline. Skip tolower() for these
-            // columns by registering them as caseSensitive with the provider.
-            const fillCellFields = (this.initialColumnDef ?? [])
-                .filter((c) => c?.columnType === 'fill' && c?.field)
-                .map((c) => c.field);
             this.odataProvider = new OdataServerSideProvider({
                 isCaseSensitiveStringFilter: false,
-                caseSensitiveColumns: fillCellFields,
+                // Always send $select listing every data-backed field from columnDefs.
+                // Without this, OData/EF projects the entire entity, which inflates
+                // both the SQL projection and the JSON payload (and the AutoMapper
+                // mapping cost). With it, the API returns only the columns the grid
+                // actually renders. The OData provider already deletes options.select
+                // for $apply/groupby requests, so aggregation queries aren't affected.
+                beforeRequest: (options) => {
+                    const selectFields = this._getServerSelectFields();
+                    if (selectFields.length > 0) {
+                        options.select = selectFields;
+                    }
+                },
                 callApi: (options) => {
                     const url = this.setExternalFilters(options);
                     console.log('Server-side API call:', url);