@stamhoofd/backend 2.83.5 → 2.84.0

package/src/services/PaymentService.ts

@@ -31,10 +31,7 @@ export const PaymentService = {
                         await BalanceItemPaymentService.markPaid(balanceItemPayment, organization);
                     }
 
-                    await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-
-                    // Reallocate
-                    await BalanceItemService.reallocate(balanceItemPayments.map(p => p.balanceItem), organization.id);
+                    await BalanceItemService.updatePaidAndPending(balanceItemPayments.map(p => p.balanceItem));
                 });
                 return;
             }
@@ -58,10 +55,7 @@ export const PaymentService = {
                         await BalanceItemPaymentService.undoPaid(balanceItemPayment, organization);
                     }
 
-                    await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-
-                    // Reallocate
-                    await BalanceItemService.reallocate(balanceItemPayments.map(p => p.balanceItem), organization.id);
+                    await BalanceItemService.updatePaidAndPending(balanceItemPayments.map(p => p.balanceItem));
                 });
             }
 
@@ -76,10 +70,7 @@ export const PaymentService = {
                         await BalanceItemPaymentService.markFailed(balanceItemPayment, organization);
                     }
 
-                    await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-
-                    // Reallocate
-                    await BalanceItemService.reallocate(balanceItemPayments.map(p => p.balanceItem), organization.id);
+                    await BalanceItemService.updatePaidAndPending(balanceItemPayments.map(p => p.balanceItem));
                 });
             }
 
@@ -94,10 +85,7 @@ export const PaymentService = {
                         await BalanceItemPaymentService.undoFailed(balanceItemPayment, organization);
                     }
 
-                    await BalanceItem.updateOutstanding(balanceItemPayments.map(p => p.balanceItem));
-
-                    // Reallocate
-                    await BalanceItemService.reallocate(balanceItemPayments.map(p => p.balanceItem), organization.id);
+                    await BalanceItemService.updatePaidAndPending(balanceItemPayments.map(p => p.balanceItem));
                 });
             }
         });

package/src/services/PlatformMembershipService.ts

@@ -138,9 +138,6 @@ export class PlatformMembershipService {
 
     static async updateMembershipsForId(id: string, silent = false) {
         if (STAMHOOFD.userMode === 'organization') {
-            if (!silent) {
-                console.warn('Skipping automatic membership for: ' + id, ' - organization mode');
-            }
             return;
         }
 
@@ -157,10 +154,17 @@ export class PlatformMembershipService {
                     }
                     return;
                 }
+                if (me.organizationId) {
+                    if (!silent) {
+                        console.warn('Cannot update members for a member with organization set', me.id);
+                    }
+                    return;
+                }
+
                 const platform = await Platform.getSharedStruct();
                 const periods = await RegistrationPeriod.select()
                     .where('locked', false)
-                    .where('organizationId', me.organizationId)
+                    .where('organizationId', null)
                     .where('endDate', SQLWhereSign.GreaterEqual, new Date()) // Avoid updating the price of past periods that were not yet locked
                     .fetch();
 

package/src/services/RegistrationService.ts

@@ -1,11 +1,12 @@
 import { ManyToOneRelation } from '@simonbackx/simple-database';
-import { Document, Group, Member, Registration } from '@stamhoofd/models';
-import { AuditLogSource, EmailTemplateType, StockReservation } from '@stamhoofd/structures';
+import { BalanceItem, Document, Group, Member, Registration } from '@stamhoofd/models';
+import { AppliedRegistrationDiscount, AuditLogSource, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, EmailTemplateType, StockReservation, TranslatedString, Version } from '@stamhoofd/structures';
 import { AuditLogService } from './AuditLogService';
 import { GroupService } from './GroupService';
 import { PlatformMembershipService } from './PlatformMembershipService';
 import { QueueHandler } from '@stamhoofd/queues';
 import { Formatter } from '@stamhoofd/utility';
+import { encodeObject, patchContainsChanges } from '@simonbackx/simple-encoding';
 
 export const RegistrationService = {
     async markValid(registrationId: string) {
@@ -44,6 +45,69 @@ export const RegistrationService = {
         return true;
     },
 
+    async updateDiscounts(registrationId: string) {
+        await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
+            await QueueHandler.schedule('registration-discounts-update-' + registrationId, async function (this: undefined) {
+                const registration = await Registration.getByID(registrationId);
+                if (!registration) {
+                    throw new Error('Registration not found');
+                }
+
+                // Fetch all discounts that have been granted to this registration
+                const discountBalanceItems = await BalanceItem.select()
+                    .where('registrationId', registrationId)
+                    .where('organizationId', registration.organizationId)
+                    .where('type', BalanceItemType.RegistrationBundleDiscount)
+                    .where('status', BalanceItemStatus.Due)
+                    .fetch();
+
+                let before: string | undefined;
+                if (STAMHOOFD.environment !== 'production') {
+                    // This is an expensive operation, so keep track of whether it was actually necessary so we can detect performance issues
+                    before = JSON.stringify(encodeObject(registration.discounts, { version: Version }));
+                }
+
+                // Reset registration discounts
+                registration.discounts = new Map();
+
+                for (const balanceItem of discountBalanceItems) {
+                    const discount = balanceItem.relations.get(BalanceItemRelationType.Discount);
+                    if (!discount) {
+                        continue;
+                    }
+
+                    let existing = registration.discounts.get(discount.id);
+
+                    if (!existing) {
+                        existing = AppliedRegistrationDiscount.create({
+                            name: discount.name,
+                            amount: 0,
+                        });
+                        registration.discounts.set(discount.id, existing);
+                    }
+                    existing.amount += -balanceItem.price; // price is negative means it has been discounted, and we store a positive amount with the discount
+
+                    if (existing.amount === 0) {
+                        // Delete the discount
+                        registration.discounts.delete(discount.id);
+                    }
+                }
+
+                console.log('Saving updated discounts for', registrationId, registration.discounts);
+
+                if (STAMHOOFD.environment !== 'production') {
+                    const after = JSON.stringify(encodeObject(registration.discounts, { version: Version }));
+                    if (before === after) {
+                        console.warn('Unnecessary update of registration discounts', registrationId, before);
+                    }
+                }
+
+                await registration.save();
+                return true;
+            });
+        });
+    },
+
     async deactivate(registration: Registration, _group?: Group, _member?: Member) {
         if (registration.deactivatedAt !== null) {
             return;

package/src/sql-filters/base-registration-filter-compilers.ts

@@ -0,0 +1,43 @@
+import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLOneToOneRelationFilterCompiler, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+import { organizationFilterCompilers } from './organizations';
+
+export const baseRegistrationFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createSQLColumnFilterCompiler('id'),
+    /**
+     * @deprecated
+     */
+    price: createSQLColumnFilterCompiler('price', { nullable: true }),
+    /**
+     * @deprecated
+     */
+    pricePaid: createSQLColumnFilterCompiler('pricePaid'),
+    canRegister: createSQLColumnFilterCompiler('canRegister'),
+    organizationId: createSQLColumnFilterCompiler('organizationId'),
+    groupId: createSQLColumnFilterCompiler('groupId'),
+    registeredAt: createSQLColumnFilterCompiler('registeredAt', { nullable: true }),
+    periodId: createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
+    deactivatedAt: createSQLColumnFilterCompiler(SQL.column('registrations', 'deactivatedAt'), { nullable: true }),
+    group: createSQLFilterNamespace({
+        ...baseSQLFilterCompilers,
+        id: createSQLColumnFilterCompiler('groupId'),
+        name: createSQLExpressionFilterCompiler(
+            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
+            { isJSONValue: true, type: SQLValueType.JSONString },
+        ),
+        status: createSQLExpressionFilterCompiler(
+            SQL.column('groups', 'status'),
+            { isJSONValue: true, type: SQLValueType.JSONString },
+        ),
+        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), { nullable: true }),
+    }),
+    organization: createSQLOneToOneRelationFilterCompiler(
+        SQL.select()
+            .from(SQL.table('organizations'))
+            .where(
+                SQL.column('organizations', 'id'),
+                SQL.column('registrations', 'organizationId'),
+            ),
+        organizationFilterCompilers,
+    ),
+};

package/src/sql-filters/groups.ts

@@ -0,0 +1,67 @@
+import { SQL, createColumnFilter, SQLModernFilterDefinitions, SQLValueType, baseModernSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQLModernValueType, createWildcardColumnFilter, SQLJsonExtract } from '@stamhoofd/sql';
+
+export const groupFilterCompilers: SQLModernFilterDefinitions = {
+    ...baseModernSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLModernValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLModernValueType.String,
+        nullable: false,
+    }),
+    periodId: createColumnFilter({
+        expression: SQL.column('periodId'),
+        type: SQLModernValueType.String,
+        nullable: false,
+    }),
+    name: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('settings'), '$.value.name'),
+        type: SQLModernValueType.JSONString,
+        nullable: false,
+    }),
+    status: createColumnFilter({
+        expression: SQL.column('status'),
+        type: SQLModernValueType.String,
+        nullable: false,
+    }),
+    defaultAgeGroupId: createColumnFilter({
+        expression: SQL.column('defaultAgeGroupId'),
+        type: SQLModernValueType.String,
+        nullable: true,
+    }),
+    bundleDiscounts: createWildcardColumnFilter(
+        (key: string) => ({
+            expression: SQL.jsonValue(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}`, true),
+            type: SQLModernValueType.JSONArray,
+            nullable: true,
+        }),
+        (key: string) => ({
+            ...baseModernSQLFilterCompilers,
+            name: createColumnFilter({
+                expression: SQL.jsonValue(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}.name`, true),
+                type: SQLModernValueType.JSONArray,
+                nullable: true,
+            }),
+        }),
+    ),
+
+    /* name: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    status: createSQLExpressionFilterCompiler(
+        SQL.column('groups', 'status'),
+        { isJSONValue: true, type: SQLValueType.JSONString },
+    ),
+    defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), { nullable: true }),
+
+    bundleDiscountIds: createSQLExpressionFilterCompiler(
+        SQL.jsonKeys(
+            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.prices[0].bundleDiscounts'),
+        ),
+        { isJSONValue: true, isJSONObject: true },
+    ), */
+};

package/src/sql-filters/members.ts

@@ -1,37 +1,39 @@
 import { SimpleError } from '@simonbackx/simple-errors';
+import { Member } from '@stamhoofd/models';
 import { SQL, SQLAge, SQLConcat, SQLFilterDefinitions, SQLScalar, SQLValueType, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from '@stamhoofd/sql';
 import { AccessRight } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { Context } from '../helpers/Context';
+import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers';
 import { organizationFilterCompilers } from './organizations';
-import { registrationFilterCompilers } from './registrations';
+
+const membersTable = SQL.table(Member.table);
 
 /**
  * Defines how to filter members in the database from StamhoofdFilter objects
  */
 export const memberFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    'id': createSQLColumnFilterCompiler('id'),
-    'memberNumber': createSQLColumnFilterCompiler('memberNumber'),
-    'firstName': createSQLColumnFilterCompiler('firstName'),
-    'lastName': createSQLColumnFilterCompiler('lastName'),
+    'id': createSQLColumnFilterCompiler(SQL.column(membersTable, 'id')),
+    'memberNumber': createSQLColumnFilterCompiler(SQL.column(membersTable, 'memberNumber')),
+    'firstName': createSQLColumnFilterCompiler(SQL.column(membersTable, 'firstName')),
+    'lastName': createSQLColumnFilterCompiler(SQL.column(membersTable, 'lastName')),
     'name': createSQLExpressionFilterCompiler(
         new SQLConcat(
-            SQL.column('firstName'),
+            SQL.column(membersTable, 'firstName'),
             new SQLScalar(' '),
-            SQL.column('lastName'),
+            SQL.column(membersTable, 'lastName'),
         ),
     ),
     'age': createSQLExpressionFilterCompiler(
-        new SQLAge(SQL.column('birthDay')),
+        new SQLAge(SQL.column(membersTable, 'birthDay')),
         { nullable: true },
     ),
     'gender': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.gender'),
+        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.gender'),
         { isJSONValue: true, type: SQLValueType.JSONString },
     ),
-
-    'birthDay': createSQLColumnFilterCompiler('birthDay', {
+    'birthDay': createSQLColumnFilterCompiler(SQL.column(membersTable, 'birthDay'), {
         normalizeValue: (d) => {
             if (typeof d === 'number') {
                 const date = new Date(d);
@@ -40,13 +42,11 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             return d;
         },
     }),
-
     'organizationName': createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'name'),
     ),
-
     'details.requiresFinancialSupport': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.requiresFinancialSupport.value'),
+        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.requiresFinancialSupport.value'),
         { isJSONValue: true, type: SQLValueType.JSONBoolean, checkPermission: async () => {
             const organization = Context.organization;
             if (!organization) {
@@ -65,97 +65,86 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             }
         } },
     ),
-
     'email': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.email'),
+        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.email'),
         { isJSONValue: true, type: SQLValueType.JSONString },
     ),
-
     'parentEmail': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.parents[*].email'),
+        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].email'),
         { isJSONValue: true, isJSONObject: true, type: SQLValueType.JSONString },
     ),
-
     'details.parents[0]': createSQLFilterNamespace({
         name: createSQLExpressionFilterCompiler(
             new SQLConcat(
-                SQL.jsonUnquotedValue(SQL.column('details'), '$.value.parents[0].firstName'),
+                SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[0].firstName'),
                 new SQLScalar(' '),
-                SQL.jsonUnquotedValue(SQL.column('details'), '$.value.parents[0].lastName'),
+                SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[0].lastName'),
             ),
             { isJSONValue: true, isJSONObject: false, type: SQLValueType.JSONString },
         ),
     }),
-
     'details.parents[1]': createSQLFilterNamespace({
         name: createSQLExpressionFilterCompiler(
             new SQLConcat(
-                SQL.jsonUnquotedValue(SQL.column('details'), '$.value.parents[1].firstName'),
+                SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[1].firstName'),
                 new SQLScalar(' '),
-                SQL.jsonUnquotedValue(SQL.column('details'), '$.value.parents[1].lastName'),
+                SQL.jsonUnquotedValue(SQL.column(membersTable, 'details'), '$.value.parents[1].lastName'),
             ),
             { isJSONValue: true, isJSONObject: false, type: SQLValueType.JSONString },
         ),
     }),
-
     'unverifiedEmail': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.unverifiedEmails'),
+        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.unverifiedEmails'),
         { isJSONValue: true, isJSONObject: true, type: SQLValueType.JSONString },
     ),
-
     'phone': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.phone'),
+        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.phone'),
         { isJSONValue: true },
     ),
-
     'details.address': createSQLFilterNamespace({
         city: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('details'), '$.value.address.city'),
+            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.city'),
             { isJSONValue: true, type: SQLValueType.JSONString },
         ),
         postalCode: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('details'), '$.value.address.postalCode'),
+            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.postalCode'),
             { isJSONValue: true, type: SQLValueType.JSONString },
         ),
         street: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('details'), '$.value.address.street'),
+            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.street'),
             { isJSONValue: true, type: SQLValueType.JSONString },
         ),
         number: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('details'), '$.value.address.number'),
+            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.address.number'),
             { isJSONValue: true, type: SQLValueType.JSONString },
         ),
     }),
-
     'details.parents[*].address': createSQLFilterNamespace({
         city: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('details'), '$.value.parents[*].address.city'),
+            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.city'),
             { isJSONValue: true, isJSONObject: true },
         ),
         postalCode: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('details'), '$.value.parents[*].address.postalCode'),
+            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.postalCode'),
             { isJSONValue: true, isJSONObject: true },
         ),
         street: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('details'), '$.value.parents[*].address.street'),
+            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.street'),
             { isJSONValue: true, isJSONObject: true },
         ),
         number: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('details'), '$.value.parents[*].address.number'),
+            SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].address.number'),
             { isJSONValue: true, isJSONObject: true },
         ),
     }),
-
     'parentPhone': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.parents[*].phone'),
+        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.parents[*].phone'),
         { isJSONValue: true, isJSONObject: true },
     ),
-
     'unverifiedPhone': createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.unverifiedPhones'),
+        SQL.jsonValue(SQL.column(membersTable, 'details'), '$.value.unverifiedPhones'),
         { isJSONValue: true, isJSONObject: true },
     ),
-
     'registrations': createSQLRelationFilterCompiler(
         SQL.select()
             .from(
@@ -168,14 +157,6 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
                     SQL.column('registrations', 'groupId'),
                 ),
             )
-            .join(
-                SQL.join(
-                    SQL.table('organizations'),
-                ).where(
-                    SQL.column('organizations', 'id'),
-                    SQL.column('registrations', 'organizationId'),
-                ),
-            )
             .where(
                 SQL.column('memberId'),
                 SQL.column('members', 'id'),
@@ -189,12 +170,8 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
                 SQL.column('groups', 'deletedAt'),
                 null,
             ),
-        {
-            ...registrationFilterCompilers,
-            organization: createSQLFilterNamespace(organizationFilterCompilers),
-        },
+        baseRegistrationFilterCompilers,
     ),
-
     'responsibilities': createSQLRelationFilterCompiler(
         SQL.select()
             .from(
@@ -236,7 +213,6 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             organization: createSQLFilterNamespace(organizationFilterCompilers),
         },
     ),
-
     'platformMemberships': createSQLRelationFilterCompiler(
         SQL.select()
             .from(
@@ -267,7 +243,6 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             generated: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'generated')),
         },
     ),
-
     'organizations': createSQLRelationFilterCompiler(
         SQL.select()
             .from(

package/src/sql-filters/organization-registration-periods.ts

@@ -0,0 +1,8 @@
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler } from '@stamhoofd/sql';
+
+export const organizationRegistrationPeriodFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createSQLColumnFilterCompiler('id'),
+    organizationId: createSQLColumnFilterCompiler('organizationId'),
+    periodId: createSQLColumnFilterCompiler('periodId'),
+};

package/src/sql-filters/registration-periods.ts

@@ -0,0 +1,8 @@
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler } from '@stamhoofd/sql';
+
+export const registrationPeriodFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createSQLColumnFilterCompiler('id'),
+    startDate: createSQLColumnFilterCompiler('startDate'),
+    endDate: createSQLColumnFilterCompiler('endDate'),
+};

package/src/sql-filters/registrations.ts

@@ -1,26 +1,15 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace, createSQLExpressionFilterCompiler, SQLValueType } from '@stamhoofd/sql';
+import { Member, Registration } from '@stamhoofd/models';
+import { baseSQLFilterCompilers, createSQLJoinedRelationFilterCompiler, SQL, SQLFilterDefinitions } from '@stamhoofd/sql';
+import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers';
+import { memberFilterCompilers } from './members';
+
+export const memberJoin = SQL.join(Member.table).where(SQL.column(Member.table, 'id'), SQL.column(Registration.table, 'memberId'));
 
 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')),
-
-    group: createSQLFilterNamespace({
-        ...baseSQLFilterCompilers,
-        id: createSQLColumnFilterCompiler('groupId'),
-        name: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        status: createSQLExpressionFilterCompiler(
-            SQL.column('groups', 'status'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), { nullable: true }),
-    }),
+    ...baseRegistrationFilterCompilers,
+    member: createSQLJoinedRelationFilterCompiler(
+        memberJoin,
+        memberFilterCompilers,
+    ),
 };

package/src/sql-sorters/groups.ts

@@ -0,0 +1,24 @@
+import { Group } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+
+export const groupSorters: SQLSortDefinitions<Group> = {
+    // 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;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction,
+            });
+        },
+    },
+};

package/src/sql-sorters/organization-registration-periods.ts

@@ -0,0 +1,24 @@
+import { OrganizationRegistrationPeriod } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+
+export const organizationRegistrationPeriodSorters: SQLSortDefinitions<OrganizationRegistrationPeriod> = {
+    // 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;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction,
+            });
+        },
+    },
+};

package/src/sql-sorters/registration-periods.ts

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