@stamhoofd/backend 2.39.1 → 2.40.0

package/src/sql-filters/registrations.ts

@@ -1,24 +1,24 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace, createSQLExpressionFilterCompiler } from "@stamhoofd/sql";
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace, createSQLExpressionFilterCompiler } from '@stamhoofd/sql';
 
 export const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    "price": createSQLColumnFilterCompiler('price', {nullable: true}),
-    "pricePaid": createSQLColumnFilterCompiler('pricePaid'),
-    "canRegister": createSQLColumnFilterCompiler('canRegister'),
-    "organizationId": createSQLColumnFilterCompiler('organizationId'),
-    "groupId": createSQLColumnFilterCompiler('groupId'),
-    "registeredAt": createSQLColumnFilterCompiler('registeredAt', {nullable: true}),
-    "periodId": createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
+    price: createSQLColumnFilterCompiler('price', { nullable: true }),
+    pricePaid: createSQLColumnFilterCompiler('pricePaid'),
+    canRegister: createSQLColumnFilterCompiler('canRegister'),
+    organizationId: createSQLColumnFilterCompiler('organizationId'),
+    groupId: createSQLColumnFilterCompiler('groupId'),
+    registeredAt: createSQLColumnFilterCompiler('registeredAt', { nullable: true }),
+    periodId: createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
 
-    "group": createSQLFilterNamespace({
+    group: createSQLFilterNamespace({
         ...baseSQLFilterCompilers,
         id: createSQLColumnFilterCompiler('groupId'),
         name: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name')
+            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
         ),
         status: createSQLExpressionFilterCompiler(
-            SQL.column('groups', 'status')
+            SQL.column('groups', 'status'),
         ),
-        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), {nullable: true}),
-    })
-}
+        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), { nullable: true }),
+    }),
+};

package/src/sql-sorters/events.ts

@@ -1,58 +1,58 @@
-import { Event } from "@stamhoofd/models"
-import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
-import { Formatter } from "@stamhoofd/utility"
+import { Event } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
 
 export const eventSorters: SQLSortDefinitions<Event> = {
     // 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,
+            });
+        },
     },
-    'startDate': {
+    startDate: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.startDate)
+            return Formatter.dateTimeIso(a.startDate);
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('startDate'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'endDate': {
+    endDate: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.endDate)
+            return Formatter.dateTimeIso(a.endDate);
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('endDate'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-}
+};

package/src/sql-sorters/members.ts

@@ -1,58 +1,58 @@
-import { MemberWithRegistrations } from "@stamhoofd/models"
-import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
-import { Formatter } from "@stamhoofd/utility"
+import { MemberWithRegistrations } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+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. 
+    // 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,
+            });
+        },
     },
-    'firstName': {
+    firstName: {
         getValue(a) {
-            return a.firstName
+            return a.firstName;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('firstName'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'lastName': {
+    lastName: {
         getValue(a) {
-            return a.lastName
+            return a.lastName;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('lastName'),
-                direction
-            })
-        }
+                direction,
+            });
+        },
     },
-    'birthDay': {
+    birthDay: {
         getValue(a) {
-            return a.details.birthDay ? Formatter.dateIso(a.details.birthDay) : null
+            return a.details.birthDay ? Formatter.dateIso(a.details.birthDay) : null;
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
                 column: SQL.column('birthDay'),
-                direction
-            })
-        }
-    }
-}
+                direction,
+            });
+        },
+    },
+};

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,
+            });
+        },
+    },
+};