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

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

@@ -239,7 +239,7 @@ class OdataProvider {
                         query = query + '&' + customFilters.join('and');
                 }
             }
-            query = query.replace('and$filter=', '&filter=');
+            query = query.replace('and$filter=', '&$filter=');
             return query;
         };
         /**
@@ -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) {
@@ -2748,6 +2788,18 @@ class GridLibraryComponent {
             let hasRetried = false;
             this.odataProvider = new OdataServerSideProvider({
                 isCaseSensitiveStringFilter: false,
+                // 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);