@stamhoofd/backend 2.39.1 → 2.40.1

package/src/sql-sorters/organizations.ts

@@ -1,79 +1,79 @@
-import { Organization } from "@stamhoofd/models"
-import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
+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. 
+    // 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': {
+
+    id: {
         getValue(a) {
-            return a.id
+            return a.id;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('id'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'name': {
+    name: {
         getValue(a) {
-            return a.name
+            return a.name;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('name'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'uri': {
+    uri: {
         getValue(a) {
-            return a.uri
+            return a.uri;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('uri'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'type': {
+    type: {
         getValue(a) {
-            return a.meta.type
+            return a.meta.type;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.jsonValue(SQL.column('meta'), '$.value.type'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'city': {
+    city: {
         getValue(a) {
-            return a.address.city
+            return a.address.city;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.jsonValue(SQL.column('address'), '$.value.city'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'country': {
+    country: {
         getValue(a) {
-            return a.address.country
+            return a.address.country;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.jsonValue(SQL.column('address'), '$.value.country'),
-                direction
-            })
-        }
-    }
-}
+                direction,
+            });
+        },
+    },
+};

package/src/sql-sorters/payments.ts

@@ -1,58 +1,58 @@
-import { Payment } from "@stamhoofd/models"
-import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
-import { Formatter } from "@stamhoofd/utility"
+import { Payment } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+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. 
+    // 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': {
+    id: {
         getValue(a) {
-            return a.id
+            return a.id;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('id'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'createdAt': {
+    createdAt: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.createdAt, 'UTC')
+            return Formatter.dateTimeIso(a.createdAt, 'UTC');
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('createdAt'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'paidAt': {
+    paidAt: {
         getValue(a) {
-            return a.paidAt !== null ? Formatter.dateTimeIso(a.paidAt, 'UTC') : null
+            return a.paidAt !== null ? Formatter.dateTimeIso(a.paidAt, 'UTC') : null;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('paidAt'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'price': {
+    price: {
         getValue(a) {
-            return a.price
+            return a.price;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('price'),
-                direction
-            })
-        }
-    }
-}
+                direction,
+            });
+        },
+    },
+};