@stamhoofd/backend 2.17.3 → 2.17.4

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.17.3",
+    "version": "2.17.4",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -60,5 +60,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "9aa2fbb9c268c4c5c45efd68a9dc55f5d48eb621"
+    "gitHead": "56f46d516a4a18cffb011caf177b5de9a14607b6"
 }

package/src/endpoints/global/files/ExportToExcelEndpoint.ts

@@ -160,7 +160,7 @@ export class ExportToExcelEndpoint extends Endpoint<Params, Query, Body, Respons
                 const writer = new XlsxWriter(zipWriterAdapter);
 
                 // Limit to pages of 100
-                request.filter.limit = 100;
+                request.filter.limit = STAMHOOFD.environment === 'development' ? 1 : 100; // in development, we need to check if total count matches and pagination is working correctly
 
                 await exportToExcel({
                     definitions: loader.sheets,

package/src/sql-filters/members.ts

@@ -9,6 +9,8 @@ import { registrationFilterCompilers } from "./registrations";
 export const memberFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
     id: createSQLColumnFilterCompiler('id'),
+    firstName: createSQLColumnFilterCompiler('firstName'),
+    lastName: createSQLColumnFilterCompiler('lastName'),
     name: createSQLExpressionFilterCompiler(
         new SQLConcat(
             SQL.column('firstName'),

package/src/sql-sorters/members.ts

@@ -3,6 +3,14 @@ import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamh
 import { Formatter } from "@stamhoofd/utility"
 
 export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields. 
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+
     'id': {
         getValue(a) {
             return a.id
@@ -14,22 +22,26 @@ export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
             })
         }
     },
-    'name': {
+    'firstName': {
+        getValue(a) {
+            return a.firstName
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('firstName'),
+                direction
+            })
+        }
+    },
+    'lastName': {
         getValue(a) {
-            // Note: we should not use 'name' here (that will remove the in between space if one is missing), because we need to use Exactly the same value as the filter will use
-            return a.firstName + ' ' + a.lastName
+            return a.lastName
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return SQLOrderBy.combine([
-                new SQLOrderBy({
-                    column: SQL.column('firstName'),
-                    direction
-                }),
-                new SQLOrderBy({
-                    column: SQL.column('lastName'),
-                    direction
-                })
-            ])
+            return new SQLOrderBy({
+                column: SQL.column('lastName'),
+                direction
+            })
         }
     },
     'birthDay': {
@@ -43,5 +55,4 @@ export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
             })
         }
     }
-    // Note: never add mapped sortings, that should happen in the frontend -> e.g. map age to birthDay
 }

package/src/sql-sorters/organizations.ts

@@ -2,6 +2,14 @@ import { Organization } from "@stamhoofd/models"
 import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
 
 export const organizationSorters: SQLSortDefinitions<Organization> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields. 
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+    
     'id': {
         getValue(a) {
             return a.id

package/src/sql-sorters/payments.ts

@@ -3,6 +3,14 @@ import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamh
 import { Formatter } from "@stamhoofd/utility"
 
 export const paymentSorters: SQLSortDefinitions<Payment> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields. 
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+
     'id': {
         getValue(a) {
             return a.id