@stamhoofd/backend 2.120.6 → 2.122.0

package/src/services/uitpas/PassholderEndpoints.ts

@@ -35,8 +35,7 @@ export class PassholderEndpoints {
                 headers: this.getHeaders(),
                 signal: AbortSignal.timeout(10000),
             });
-        }
-        catch (error) {
+        } catch (error) {
             if (isTimeout(error)) {
                 throw new SimpleError({
                     statusCode: 408,
@@ -60,8 +59,7 @@ export class PassholderEndpoints {
         try {
             const json = await handleUitpasResponse(response);
             return jsonToGetPassResponse(json);
-        }
-        catch (e) {
+        } catch (e) {
             if (isSimpleError(e) || isSimpleErrors(e)) {
                 if (e.hasCode('https://api.publiq.be/probs/uitpas/pass-not-found')) {
                     throw new SimpleError({
@@ -168,8 +166,7 @@ function assertValidGetPassResponse(json: unknown): asserts json is GetPassRespo
                 }
             });
         }
-    }
-    catch (error) {
+    } catch (error) {
         console.error('Invalid response when retrieving pass by UiTPAS number:', json);
         throw new SimpleError({
             code: 'invalid_response_retrieving_pass_by_uitpas_number',

package/src/services/uitpas/UitpasService.ts

@@ -12,9 +12,9 @@ import { checkPermissionsFor } from './checkPermissionsFor.js';
 import { checkUitpasNumbers } from './checkUitpasNumbers.js';
 import { getSocialTariffForEvent } from './getSocialTariffForEvent.js';
 import { getSocialTariffForUitpasNumbers } from './getSocialTariffForUitpasNumbers.js';
-import type { GetPassResponse} from './PassholderEndpoints.js';
+import type { GetPassResponse } from './PassholderEndpoints.js';
 import { PassholderEndpoints } from './PassholderEndpoints.js';
-import type { RegisterTicketSaleRequest, RegisterTicketSaleResponse} from './registerTicketSales.js';
+import type { RegisterTicketSaleRequest, RegisterTicketSaleResponse } from './registerTicketSales.js';
 import { registerTicketSales } from './registerTicketSales.js';
 import { searchUitpasEvents } from './searchUitpasEvents.js';
 import { searchUitpasOrganizers } from './searchUitpasOrganizers.js';
@@ -202,8 +202,7 @@ export class UitpasService {
                 }
                 try {
                     newlyRegistered = await registerTicketSales(access_token, toBeRegisteredUitpasRequests);
-                }
-                catch (e) {
+                } catch (e) {
                     console.error('Failed to register UiTPAS ticket sales', e);
                 }
             }
@@ -269,8 +268,7 @@ export class UitpasService {
                         }
                     }
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 console.error('Failed to update UiTPAS-numbers after order update', e);
             }
         });
@@ -353,8 +351,7 @@ export class UitpasService {
         let access_token!: string;
         try {
             access_token = await UitpasTokenRepository.getAccessTokenFor(); // use platform credentials
-        }
-        catch (e) {
+        } catch (e) {
             if (isSimpleError(e) && e.hasCode('uitpas_api_not_configured_for_platform')) {
                 console.error('UiTPAS API has not been configured for this platform, so defaulting to an unknown status for number ', uitpasNumber);
                 // Ignore and return status of unknown
@@ -444,8 +441,7 @@ export class UitpasService {
                         });
                     }
                 }
-            }
-            else {
+            } else {
                 // non-official flow
                 access_token_platform = access_token_platform ?? await UitpasTokenRepository.getAccessTokenFor();
                 await checkUitpasNumbers(access_token_platform, item.uitpasNumbers.map(p => p.uitpasNumber));

package/src/services/uitpas/checkUitpasNumbers.ts

@@ -39,14 +39,12 @@ export async function checkUitpasNumbers(access_token: string, uitpasNumbers: st
                     ),
                 });
             }
-        }
-        catch (e) {
+        } catch (e) {
             if (isSimpleError(e) || isSimpleErrors(e)) {
                 e.addNamespace(i.toString());
                 e.addNamespace('uitpasNumbers');
                 simpleErrors.addError(e);
-            }
-            else {
+            } else {
                 throw e;
             }
         }

package/src/services/uitpas/getSocialTariffForUitpasNumbers.ts

@@ -90,8 +90,7 @@ async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber
 
         if (json) {
             console.error(`UiTPAS API returned an error for UiTPAS number ${uitpasNumber} with event id ${eventId}:`, json);
-        }
-        else {
+        } else {
             console.error(`UiTPAS API returned an error for UiTPAS number ${uitpasNumber} with event id ${eventId}:`, response.statusText);
         }
 
@@ -168,14 +167,12 @@ export async function getSocialTariffForUitpasNumbers(access_token: string, uitp
         const uitpasNumber = uitpasNumbers[i];
         try {
             reducedPrices[i] = await getSocialTariffForUitpasNumber(access_token, uitpasNumber, basePrice, uitpasEventUrl);
-        }
-        catch (e) {
+        } catch (e) {
             if (isSimpleError(e) || isSimpleErrors(e)) {
                 e.addNamespace(i.toString());
                 e.addNamespace('uitpasNumbers');
                 simpleErrors.addError(e);
-            }
-            else {
+            } else {
                 throw e;
             }
         }

package/src/services/uitpas/searchUitpasEvents.ts

@@ -124,8 +124,7 @@ export async function searchUitpasEvents(clientId: string, uitpasOrganizerId: st
         const hasNl = entrs.find(([key]) => key === 'nl');
         if (hasNl) {
             event.location = locationName.nl;
-        }
-        else {
+        } else {
             const lang = entrs[0];
             event.location = lang ? lang[1] : '';
         }

package/src/sql-filters/audit-logs.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const auditLogFilterCompilers: SQLFilterDefinitions = {

package/src/sql-filters/balance-item-payments.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {

package/src/sql-filters/balance-items.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 /**

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

@@ -1,43 +1,15 @@
-import { SimpleError } from '@simonbackx/simple-errors';
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, createJoinedRelationFilter, SQL, SQLIfNull, SQLValueType } from '@stamhoofd/sql';
-import type { StamhoofdFilter} from '@stamhoofd/structures';
-import { FilterWrapperMarker, PermissionLevel, unwrapFilter } from '@stamhoofd/structures';
+import type { StamhoofdFilter } from '@stamhoofd/structures';
+import { PermissionLevel } from '@stamhoofd/structures';
 import { Context } from '../helpers/Context.js';
 import { memberCachedBalanceForOrganizationJoin, registrationCachedBalanceJoin } from '../helpers/outstandingBalanceJoin.js';
 import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
+import { StamhoofdFilterAccessHelper } from '../helpers/StamhoofdFilterAccessHelper.js';
 import { organizationFilterCompilers } from './organizations.js';
 
 async function checkGroupIdFilterAccess(filter: StamhoofdFilter, permissionLevel: PermissionLevel) {
-    const groupIds = typeof filter === 'string'
-        ? [filter]
-        : unwrapFilter(filter as StamhoofdFilter, {
-            $in: FilterWrapperMarker,
-        })?.markerValue;
-
-    if (!Array.isArray(groupIds)) {
-        throw new SimpleError({
-            code: 'invalid_field',
-            field: 'filter',
-            message: 'You must filter on a group of the organization you are trying to access',
-            human: $t(`%1HG`),
-        });
-    }
-
-    if (groupIds.length === 0) {
-        return;
-    }
-
-    for (const groupId of groupIds) {
-        if (typeof groupId !== 'string') {
-            throw new SimpleError({
-                code: 'invalid_field',
-                field: 'filter',
-                message: 'Invalid group ID in filter',
-            });
-        }
-    }
-
+    const groupIds = StamhoofdFilterAccessHelper.getGroupIdsFromFilter(filter);
     const groups = await Context.auth.getGroups(groupIds as string[]);
 
     console.log('Filtering registrations on groups', groups.map(g => g.settings.name.toString()));

package/src/sql-filters/document-templates.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const documentTemplateFilterCompilers: SQLFilterDefinitions = {

package/src/sql-filters/documents.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const documentFilterCompilers: SQLFilterDefinitions = {

package/src/sql-filters/email-recipients.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLConcat, SQLScalar, SQLValueType } from '@stamhoofd/sql';
 
 export const emailRecipientsFilterCompilers: SQLFilterDefinitions = {

package/src/sql-filters/emails.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 import { emailRecipientsFilterCompilers } from './email-recipients.js';
 

package/src/sql-filters/event-notifications.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createJoinedRelationFilter, createExistsFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 import { eventFilterCompilers } from './events.js';
 import { organizationFilterCompilers } from './organizations.js';

package/src/sql-filters/events.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const eventFilterCompilers: SQLFilterDefinitions = {
@@ -107,6 +107,11 @@ export const eventFilterCompilers: SQLFilterDefinitions = {
                 type: SQLValueType.JSONNumber,
                 nullable: true,
             }),
+            periodId: createColumnFilter({
+                expression: SQL.column('periodId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
         },
     ),
     'webshop': createExistsFilter(

package/src/sql-filters/groups.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createWildcardColumnFilter, SQL, SQLJsonExtract, SQLValueType } from '@stamhoofd/sql';
 import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
 
@@ -34,6 +34,21 @@ export const groupFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    type: createColumnFilter({
+        expression: SQL.column('type'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    waitingListId: createColumnFilter({
+        expression: SQL.column('waitingListId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    deletedAt: createColumnFilter({
+        expression: SQL.column('deletedAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
     bundleDiscounts: createWildcardColumnFilter(
         (key: string) => ({
             expression: SQL.jsonExtract(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}`, true),

package/src/sql-filters/invoiced-balance-items.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const invoicedBalanceItemCompilers: SQLFilterDefinitions = {

package/src/sql-filters/invoices.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLCast, SQLConcat, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
 import { invoicedBalanceItemCompilers } from './invoiced-balance-items.js';
 

package/src/sql-filters/member-responsibility-records.ts

@@ -1,5 +1,5 @@
 import { MemberResponsibilityRecord } from '@stamhoofd/models';
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 const baseTable = SQL.table(MemberResponsibilityRecord.table);

package/src/sql-filters/members.ts

@@ -1,6 +1,6 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Email, Member, MemberUser } from '@stamhoofd/models';
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, createWildcardColumnFilter, SQL, SQLAge, SQLCast, SQLConcat, SQLJsonExtract, SQLScalar, SQLValueType } from '@stamhoofd/sql';
 import { AccessRight } from '@stamhoofd/structures';
 import { Context } from '../helpers/Context.js';

package/src/sql-filters/orders.ts

@@ -121,7 +121,7 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
             expression: SQL.jsonExtract(SQL.column('data'), '$.value.discountCodes[*].code'),
             type: SQLValueType.JSONArray,
             nullable: true,
-        })
+        }),
     },
     items: createExistsFilter(
         /**
@@ -230,14 +230,14 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
                 ).where(
                     SQL.column('balance_items', 'id'),
                     SQL.column('balance_item_payments', 'balanceItemId'),
-                )
+                ),
             )
             .join(
                 SQL.join(
                     SQL.table('payments'),
                 ).where(
                     SQL.column('payments', 'id'),
-                    SQL.column('balance_item_payments', 'paymentId')
+                    SQL.column('balance_item_payments', 'paymentId'),
                 ),
             )
             .where(
@@ -247,7 +247,7 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
             // payments on structure filter away failed payments -> also filter out failed payments in backend
             .whereNot(
                 SQL.column('payments', 'status'),
-                PaymentStatus.Failed
+                PaymentStatus.Failed,
             ),
         {
             ...baseSQLFilterCompilers,

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

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const organizationRegistrationPeriodFilterCompilers: SQLFilterDefinitions = {

package/src/sql-filters/organizations.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLConcat, SQLNow, SQLNull, SQLScalar, SQLValueType, SQLWhereEqual, SQLWhereOr, SQLWhereSign } from '@stamhoofd/sql';
 import { SetupStepType } from '@stamhoofd/structures';
 

package/src/sql-filters/payments.ts

@@ -38,6 +38,11 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    invoiceId: createColumnFilter({
+        expression: SQL.column('invoiceId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     createdAt: createColumnFilter({
         expression: SQL.column('createdAt'),
         type: SQLValueType.Datetime,

package/src/sql-filters/platform-memberships.ts

@@ -58,7 +58,7 @@ export const platformMembershipFilterCompilers: SQLFilterDefinitions = {
                 SQL.column('organizations', 'id'),
                 SQL.column(MemberPlatformMembership.table, 'organizationId'),
             ),
-        organizationFilterCompilers
+        organizationFilterCompilers,
     ),
     member: createExistsFilter(
         SQL.select()
@@ -67,6 +67,6 @@ export const platformMembershipFilterCompilers: SQLFilterDefinitions = {
                 SQL.column('members', 'id'),
                 SQL.column(MemberPlatformMembership.table, 'memberId'),
             ),
-        memberFilterCompilers
-    )
+        memberFilterCompilers,
+    ),
 };

package/src/sql-filters/receivable-balances.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLConcat, SQLValueType, SQLScalar } from '@stamhoofd/sql';
 import { memberFilterCompilers } from './members.js';
 import { organizationFilterCompilers } from './organizations.js';

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

@@ -0,0 +1,90 @@
+import { Group, Member, Organization, RegistrationInvitation } from '@stamhoofd/models';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createJoinedRelationFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
+import { memberFilterCompilers } from './members.js';
+
+export const memberJoin = SQL.join(Member.table).where(SQL.column(Member.table, 'id'), SQL.column(RegistrationInvitation.table, 'memberId'));
+
+export const groupJoin = SQL.join(Group.table).where(SQL.column(Group.table, 'id'), SQL.column(RegistrationInvitation.table, 'groupId'));
+
+export const organizationJoin = SQL.join(Organization.table).where(SQL.column(Organization.table, 'id'), SQL.column(RegistrationInvitation.table, 'organizationId'));
+
+export const registrationInvitationFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    groupId: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'groupId'),
+        type: SQLValueType.String,
+        nullable: false,
+        // todo?
+        // async checkPermission(filter) {
+        //     await checkGroupIdFilterAccess(filter, PermissionLevel.Read);
+        // },
+    }),
+    memberId: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'memberId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    member: createJoinedRelationFilter(
+        memberJoin,
+        memberFilterCompilers,
+    ),
+    group: createJoinedRelationFilter(
+        groupJoin,
+        {
+            ...baseSQLFilterCompilers,
+            id: createColumnFilter({
+                expression: SQL.column('groupId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            periodId: createColumnFilter({
+                expression: SQL.column('periodId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            type: createColumnFilter({
+                expression: SQL.column('groups', 'type'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            name: createColumnFilter({
+                expression: new SQLTranslatedString(SQL.column('groups', 'settings'), '$.value.name'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            status: createColumnFilter({
+                expression: SQL.column('groups', 'status'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            defaultAgeGroupId: createColumnFilter({
+                expression: SQL.column('groups', 'defaultAgeGroupId'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            // temporary keep filter for testing
+            deletedAt: createColumnFilter({
+                expression: SQL.column('groups', 'deletedAt'),
+                type: SQLValueType.Datetime,
+                nullable: true,
+            }),
+        },
+    ),
+};

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

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const registrationPeriodFilterCompilers: SQLFilterDefinitions = {

package/src/sql-filters/registrations.ts

@@ -1,5 +1,5 @@
 import { Group, Member, Organization, Registration } from '@stamhoofd/models';
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createJoinedRelationFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
 import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers.js';

package/src/sql-filters/tickets.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const ticketFilterCompilers: SQLFilterDefinitions = {

package/src/sql-filters/users.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
 
 export const userFilterCompilers: SQLFilterDefinitions = {

package/src/sql-sorters/groups.ts

@@ -1,6 +1,7 @@
 import type { Group } from '@stamhoofd/models';
 import type { SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
 import { SQL, SQLOrderBy } from '@stamhoofd/sql';
+import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
 
 export const groupSorters: SQLSortDefinitions<Group> = {
     // WARNING! TEST NEW SORTERS THOROUGHLY!
@@ -22,4 +23,26 @@ export const groupSorters: SQLSortDefinitions<Group> = {
             });
         },
     },
+    periodId: {
+        getValue(a) {
+            return a.periodId;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('periodId'),
+                direction,
+            });
+        },
+    },
+    name: {
+        getValue(a) {
+            return a.settings.name.toString();
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: new SQLTranslatedString(SQL.column('settings'), '$.value.name'),
+                direction,
+            });
+        },
+    },
 };

package/src/sql-sorters/platform-memberships.ts

@@ -4,10 +4,10 @@ import { SQL, SQLOrderBy } from '@stamhoofd/sql';
 import type { PlatformMembership } from '@stamhoofd/structures';
 
 type KeysOfType<T, V> = {
-  [K in keyof T]: T[K] extends V ? K : never
+    [K in keyof T]: T[K] extends V ? K : never
 }[keyof T];
 
-const columnsToFilterOn: (KeysOfType<PlatformMembership, PlainObject | Date>)[] = ['id','startDate','endDate','membershipTypeId', 'price', 'createdAt', 'trialUntil', 'freeAmount'];
+const columnsToFilterOn: (KeysOfType<PlatformMembership, PlainObject | Date>)[] = ['id', 'startDate', 'endDate', 'membershipTypeId', 'price', 'createdAt', 'trialUntil', 'freeAmount'];
 
 export const platformMembershipSorters: SQLSortDefinitions<PlatformMembership> = {
     // WARNING! TEST NEW SORTERS THOROUGHLY!
@@ -17,24 +17,24 @@ export const platformMembershipSorters: SQLSortDefinitions<PlatformMembership> =
     // 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.
-    ...Object.fromEntries(columnsToFilterOn.map((column: KeysOfType<PlatformMembership, PlainObject | Date>) => [column, createColumnSortDefinition(column)]))
+    ...Object.fromEntries(columnsToFilterOn.map((column: KeysOfType<PlatformMembership, PlainObject | Date>) => [column, createColumnSortDefinition(column)])),
 };
 
 /**
  * Create a basic sort definition from a column
- * @param column 
- * @returns 
+ * @param column
+ * @returns
  */
-function createColumnSortDefinition<K extends KeysOfType<PlatformMembership, PlainObject | Date>>(column: K): SQLSortDefinition<PlatformMembership, PlatformMembership[K]>{
+function createColumnSortDefinition<K extends KeysOfType<PlatformMembership, PlainObject | Date>>(column: K): SQLSortDefinition<PlatformMembership, PlatformMembership[K]> {
     return {
-            getValue(a: PlatformMembership) {
-                return a[column];
-            },
-            toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-                return new SQLOrderBy({
-                    column: SQL.column(column),
-                    direction,
-                });
-            },
-    }
+        getValue(a: PlatformMembership) {
+            return a[column];
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column(column),
+                direction,
+            });
+        },
+    };
 }