@stamhoofd/backend 2.115.1 → 2.117.0

package/src/services/PlatformMembershipService.ts

@@ -5,8 +5,8 @@ import { QueueHandler } from '@stamhoofd/queues';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
 import { AuditLogSource, PlatformMembershipTypeBehaviour } from '@stamhoofd/structures';
 import { Formatter, Sorter } from '@stamhoofd/utility';
-import { AuditLogService } from './AuditLogService';
-import { MemberNumberService } from './MemberNumberService';
+import { AuditLogService } from './AuditLogService.js';
+import { MemberNumberService } from './MemberNumberService.js';
 
 export class PlatformMembershipService {
     static listen() {
@@ -147,7 +147,7 @@ export class PlatformMembershipService {
                     console.log('update memberships for id ', id);
                 }
 
-                const me = await Member.getWithRegistrations(id);
+                const me = await Member.getByIdWithRegistrationsAndGroups(id);
                 if (!me) {
                     if (!silent) {
                         console.log('Skipping automatic membership for: ' + id, ' - member not found');

package/src/services/RegistrationService.ts

@@ -1,9 +1,9 @@
 import { ManyToOneRelation } from '@simonbackx/simple-database';
 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 { AuditLogService } from './AuditLogService.js';
+import { GroupService } from './GroupService.js';
+import { PlatformMembershipService } from './PlatformMembershipService.js';
 import { QueueHandler } from '@stamhoofd/queues';
 import { Formatter } from '@stamhoofd/utility';
 import { encodeObject } from '@simonbackx/simple-encoding';

package/src/services/SSOService.ts

@@ -4,9 +4,9 @@ import { Organization, Platform, Token, User, Webshop } from '@stamhoofd/models'
 import { LoginMethod, LoginProviderType, OpenIDClientConfiguration, StartOpenIDFlowStruct, Token as TokenStruct } from '@stamhoofd/structures';
 import crypto from 'crypto';
 import { generators, Issuer } from 'openid-client';
-import { Context } from '../helpers/Context';
+import { Context } from '../helpers/Context.js';
 
-import { CookieHelper, ObjectWithHeaders } from '../helpers/CookieHelper';
+import { CookieHelper, ObjectWithHeaders } from '../helpers/CookieHelper.js';
 
 async function randomBytes(size: number): Promise<Buffer> {
     return new Promise((resolve, reject) => {

package/src/services/STPackageService.ts

@@ -0,0 +1,241 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { BalanceItem, Organization, Platform, Registration, STPackage } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, Country, PaymentCustomer, STPackageStatus, STPackageType, STPricingType, TranslatedString, VATExcemptReason } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { GroupBuilder } from '../helpers/GroupBuilder.js';
+
+export class STPackageService {
+    static async getActivePackages(organizationId: string) {
+        return await STPackage.select()
+            .where('organizationId', organizationId)
+            .andWhere('validAt', '!=', null)
+            .andWhere(
+                SQL.where('removeAt', null)
+                    .or('removeAt', '>', new Date()),
+            )
+            .fetch();
+    }
+
+    /**
+     * Returns an up to date amount that should be charged for this package.
+     * Note that this value could be smaller than the already charged amount.
+     */
+    static async getChargeableQuantity(pack: STPackage) {
+        // If type is
+        let amount = 1;
+        let membersCount: number | null = null;
+
+        if (membersCount === null && pack.meta.pricingType === STPricingType.PerMember) {
+            membersCount = await Registration.getActiveMembers(pack.organizationId);
+        }
+
+        if (pack.meta.pricingType === STPricingType.PerMember) {
+            amount = membersCount ?? 1;
+        }
+
+        if (amount < pack.meta.minimumAmount) {
+            amount = pack.meta.minimumAmount;
+        }
+
+        return amount;
+    }
+
+    static async markValid(packageId: string) {
+        const pack = await STPackage.getByID(packageId);
+        if (!pack) {
+            console.error('Missing STPackage when marking STPackage as valid', packageId);
+            return;
+        }
+        if (pack.validAt) {
+            // Already valid
+            return;
+        }
+
+        console.log('Marking STPackage as valid', packageId);
+        pack.validAt = new Date();
+        await pack.save();
+
+        if (pack.meta.didRenewId) {
+            const didRenewPackage = await STPackage.getByID(pack.meta.didRenewId);
+            if (didRenewPackage && didRenewPackage.organizationId === pack.organizationId) {
+                await this.didRenew(didRenewPackage, pack);
+            }
+        }
+
+        await this.updateOrganizationPackages(pack.organizationId);
+    }
+
+    static async didRenew(old: STPackage, renewedBy: STPackage) {
+        old.removeAt = renewedBy.meta.startDate ?? renewedBy.validAt ?? new Date();
+        old.meta.allowRenew = false;
+        await old.save();
+    }
+
+    static async getPaidOrPendingQuantity(pack: STPackage) {
+        if (!pack.existsInDatabase || pack.createdAt.getTime() > Date.now() - 1_000) {
+            return 0;
+        }
+
+        return await BalanceItem.select()
+            .where('packageId', pack.id)
+            .where('status', BalanceItemStatus.Due)
+            .count(SQL.column('amount'));
+    }
+
+    /**
+     * Create a balance item to charge an increase in amount of a given package.
+     *
+     * Convertable into STInvoiceItem (or the diffence if amount is increased)
+     * Use this to calculate prices or create an invoice
+     * This will calculate the price to expand the package to the given amount.
+     * If you want to renew a package, you need to create a new package first
+     */
+    static async chargePackage(pack: STPackage, date?: Date, customer?: PaymentCustomer): Promise<BalanceItem | null> {
+        let unitPrice = Math.round(pack.meta.unitPrice);
+
+        let amount = await this.getChargeableQuantity(pack);
+
+        if (amount < pack.meta.minimumAmount) {
+            // Minimum should get applied first, because we might already have paid for the minimum (paid amount)
+            amount = pack.meta.minimumAmount;
+        }
+
+        const paid = await this.getPaidOrPendingQuantity(pack);
+        amount -= paid;
+
+        if (amount <= 0) {
+            amount = 0;
+        }
+
+        if (amount <= 0) {
+            return null;
+        }
+
+        /// When pricing type is memebrs, the price is calculated per year.
+        /// If a shorter period is remaining, we give a discount in order
+        /// to no need to handle it more complicated
+        let now = date ?? new Date();
+        if (now < pack.meta.startDate) {
+            // When creating a new package, we sometimes buy it for the future, so use that date instead of now
+            now = pack.meta.startDate;
+        }
+
+        if (pack.validUntil && pack.meta.pricingType !== STPricingType.Fixed) {
+            const totalDays = Math.round((pack.validUntil.getTime() - pack.meta.startDate.getTime()) / (1000 * 60 * 60 * 24));
+            let remainingDays = Math.round((pack.validUntil.getTime() - now.getTime()) / (1000 * 60 * 60 * 24));
+
+            /// First 3 months are full price
+            const paidDays = 30 * 3;
+
+            if (remainingDays > totalDays) {
+                remainingDays = totalDays;
+            }
+
+            if (totalDays > 366) {
+                // Increase unit price
+                unitPrice = unitPrice * (totalDays / 365);
+            }
+
+            if (pack.meta.pricingType === STPricingType.PerMember) {
+                unitPrice = Math.round(Math.min(unitPrice, unitPrice * remainingDays / (Math.max(365, totalDays) - paidDays)));
+            }
+            else {
+                unitPrice = Math.round(unitPrice);
+            }
+        }
+
+        const item = new BalanceItem();
+        item.type = BalanceItemType.STPackage;
+        item.description = pack.meta.name + ' ' + (
+            pack.validUntil
+                ? $t('58b2c936-9025-4613-a9be-9d9bab212ea6', { startDate: Formatter.date(now, true), endDate: Formatter.date(pack.validUntil, true) })
+                : $t('33b8f500-248a-4020-b775-4dd437ca0173', { startDate: Formatter.date(pack.meta.startDate, true) })
+        );
+        item.relations.set(BalanceItemRelationType.STPackage, BalanceItemRelation.create({
+            id: pack.id,
+            name: TranslatedString.create(pack.meta.name),
+        }));
+        item.packageId = pack.id;
+        item.startDate = now;
+
+        if (pack.validUntil) {
+            item.endDate = pack.validUntil;
+        }
+
+        item.payingOrganizationId = pack.organizationId;
+        const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+        if (!membershipOrganizationId) {
+            throw new SimpleError({
+                code: 'unavailable',
+                message: 'No membership organization id set on the platform',
+                human: 'Package purchases are currently unavailable',
+            });
+        }
+        item.organizationId = membershipOrganizationId;
+        item.VATPercentage = 21;
+        item.VATIncluded = false;
+        item.VATExcempt = null;
+        item.quantity = amount;
+        item.unitPrice = unitPrice;
+        item.createdAt = now;
+        item.status = BalanceItemStatus.Hidden;
+
+        if (customer && customer.company && customer.company.address) {
+            // Reverse charged vat applicable?
+            if (customer.company.address.country !== Country.Belgium) {
+                item.VATExcempt = VATExcemptReason.IntraCommunity;
+            }
+        }
+
+        return item;
+    }
+
+    private static async getForOrganizationIncludingExpired(organizationId: string) {
+        const packages = await STPackage.select()
+            .where('organizationId', organizationId)
+            .where('validAt', '!=', null)
+            .orderBy('validAt', 'DESC')
+            .fetch();
+
+        return packages;
+    }
+
+    private static async getOrganizationPackagesMap(organizationId: string): Promise<Map<STPackageType, STPackageStatus>> {
+        const packages = await this.getForOrganizationIncludingExpired(organizationId);
+
+        const map = new Map<STPackageType, STPackageStatus>();
+        for (const pack of packages) {
+            const exist = map.get(pack.meta.type);
+            if (exist) {
+                exist.merge(pack.createStatus());
+            }
+            else {
+                map.set(pack.meta.type, pack.createStatus());
+            }
+        }
+
+        return map;
+    }
+
+    static async updateOrganizationPackages(organizationId: string) {
+        console.log('Updating packages for organization ' + organizationId);
+        const map = await this.getOrganizationPackagesMap(organizationId);
+
+        const organization = await Organization.getByID(organizationId);
+        if (organization) {
+            const didUseMembers = organization.meta.packages.useMembers && organization.meta.packages.useActivities;
+            organization.meta.packages.packages = map;
+            await organization.save();
+
+            if (!didUseMembers && organization.meta.packages.useMembers && organization.meta.packages.useActivities) {
+                console.log('Building groups and categories for ' + organization.id);
+                const builder = new GroupBuilder(organization);
+                await builder.build();
+            }
+        }
+        else {
+            console.error("Couldn't find organization when updating packages " + organizationId);
+        }
+    }
+}

package/src/services/uitpas/UitpasService.test.ts

@@ -1,5 +1,5 @@
 import { STExpect } from '@stamhoofd/test-utils';
-import { UitpasService } from './UitpasService';
+import { UitpasService } from './UitpasService.js';
 
 describe.skip('UitpasService', () => {
     it('should validate a correct Uitpas number with kansentarief', async () => {

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

@@ -0,0 +1,56 @@
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+
+/**
+ * Defines how to filter balance items in the database from StamhoofdFilter objects
+ */
+export const balanceItemFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    type: createColumnFilter({
+        expression: SQL.column('type'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    status: createColumnFilter({
+        expression: SQL.column('status'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    updatedAt: createColumnFilter({
+        expression: SQL.column('updatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+
+    description: createColumnFilter({
+        expression: SQL.column('description'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+
+    priceWithVAT: createColumnFilter({
+        expression: SQL.column('priceTotal'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+
+    priceOpen: createColumnFilter({
+        expression: SQL.column('priceOpen'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+};

package/src/sql-filters/emails.ts

@@ -1,5 +1,5 @@
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
-import { emailRecipientsFilterCompilers } from './email-recipients';
+import { emailRecipientsFilterCompilers } from './email-recipients.js';
 
 export const userEmailFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,

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

@@ -1,6 +1,6 @@
 import { baseSQLFilterCompilers, createColumnFilter, createJoinedRelationFilter, createExistsFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
-import { eventFilterCompilers } from './events';
-import { organizationFilterCompilers } from './organizations';
+import { eventFilterCompilers } from './events.js';
+import { organizationFilterCompilers } from './organizations.js';
 
 export const organizationJoin = SQL.join('organizations').where(SQL.column('organizations', 'id'), SQL.column('event_notifications', 'organizationId'));
 

package/src/sql-filters/events.ts

@@ -37,6 +37,11 @@ export const eventFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    'webshopId': createColumnFilter({
+        expression: SQL.column('webshopId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     'typeId': createColumnFilter({
         expression: SQL.column('typeId'),
         type: SQLValueType.String,
@@ -81,6 +86,52 @@ export const eventFilterCompilers: SQLFilterDefinitions = {
                 type: SQLValueType.String,
                 nullable: false,
             }),
+            status: createColumnFilter({
+                expression: SQL.column('status'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            registrationStartDate: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('settings'), '$.value.registrationStartDate'),
+                type: SQLValueType.JSONNumber,
+                nullable: true,
+            }),
+            registrationEndDate: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('settings'), '$.value.registrationEndDate'),
+                type: SQLValueType.JSONNumber,
+                nullable: true,
+            }),
+            preRegistrationsDate: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('settings'), '$.value.preRegistrationsDate'),
+                type: SQLValueType.JSONNumber,
+                nullable: true,
+            }),
+        },
+    ),
+    'webshop': createExistsFilter(
+        SQL.select()
+            .from(SQL.table('webshops'))
+            .where(
+                SQL.column('id'),
+                SQL.column('events', 'webshopId'),
+            ),
+        {
+            ...baseSQLFilterCompilers,
+            status: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('meta'), '$.value.status'),
+                type: SQLValueType.JSONString,
+                nullable: false,
+            }),
+            availableUntil: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('meta'), '$.value.availableUntil'),
+                type: SQLValueType.JSONNumber,
+                nullable: true,
+            }),
+            openAt: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('meta'), '$.value.openAt'),
+                type: SQLValueType.JSONNumber,
+                nullable: true,
+            }),
         },
     ),
 };

package/src/sql-filters/members.ts

@@ -1,10 +1,11 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Email, Member } from '@stamhoofd/models';
+import { Email, Member, MemberUser } from '@stamhoofd/models';
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, createWildcardColumnFilter, SQL, SQLAge, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonExtract, SQLScalar, SQLValueType } from '@stamhoofd/sql';
 import { AccessRight } from '@stamhoofd/structures';
 import { Context } from '../helpers/Context.js';
 import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers.js';
 import { organizationFilterCompilers } from './organizations.js';
+import { userFilterCompilers } from './users.js';
 
 const membersTable = SQL.table(Member.table);
 
@@ -84,6 +85,11 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             await throwIfNoFinancialReadAccess();
         },
     }),
+    'details.dataPermissions': createColumnFilter({
+        expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.dataPermissions.value'),
+        type: SQLValueType.JSONBoolean,
+        nullable: true,
+    }),
     'email': createColumnFilter({
         expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.email'),
         type: SQLValueType.JSONString,
@@ -94,6 +100,16 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.JSONArray,
         nullable: true,
     }),
+    'details.emergencyContacts.length': createColumnFilter({
+        expression: SQL.jsonLength(SQL.column(membersTable, 'details'), '$.value.emergencyContacts'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    'details.parents.length': createColumnFilter({
+        expression: SQL.jsonLength(SQL.column(membersTable, 'details'), '$.value.parents'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
     'details.parents[0]': {
         ...baseSQLFilterCompilers,
         name: createColumnFilter({
@@ -154,6 +170,12 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             type: SQLValueType.JSONString,
             nullable: true,
         }),
+        // for checking if the address is null
+        value: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column(membersTable, 'details'), '$.value.address'),
+            type: SQLValueType.JSONObject,
+            nullable: true,
+        }),
     },
     'details.parents[*].address': {
         ...baseSQLFilterCompilers,
@@ -217,7 +239,7 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             ...baseRegistrationFilterCompilers,
             // Override the registration periodId - can be outdated - and always use the group periodId
             periodId: createColumnFilter({
-                expression: SQL.column('groups', 'periodId'),
+                expression: SQL.column('registrations', 'periodId'),
                 type: SQLValueType.String,
                 nullable: false,
             }),
@@ -497,6 +519,20 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             },
         ),
     },
+    'users': createExistsFilter(
+        SQL.select()
+            .from(
+                SQL.table('users'),
+            ).join(
+                SQL.innerJoin(MemberUser.table)
+                    .where(
+                        SQL.parentColumn('id'),
+                        SQL.column('usersId'),
+                    ),
+            )
+            .where(SQL.column(MemberUser.table, 'membersId'), SQL.column('members', 'id')),
+        userFilterCompilers,
+    ),
 };
 
 async function throwIfNoFinancialReadAccess() {

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

@@ -1,7 +1,7 @@
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLConcat, SQLFilterDefinitions, SQLValueType, SQLScalar } from '@stamhoofd/sql';
-import { memberFilterCompilers } from './members';
-import { organizationFilterCompilers } from './organizations';
-import { EmailRelationFilterCompilers } from './shared/EmailRelationFilterCompilers';
+import { memberFilterCompilers } from './members.js';
+import { organizationFilterCompilers } from './organizations.js';
+import { EmailRelationFilterCompilers } from './shared/EmailRelationFilterCompilers.js';
 
 /**
  * Defines how to filter cached balance items in the database from StamhoofdFilter objects

package/src/sql-filters/users.ts

@@ -0,0 +1,10 @@
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+
+export const userFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    verified: createColumnFilter({
+        expression: SQL.column('verified'),
+        type: SQLValueType.Boolean,
+        nullable: false,
+    }),
+};

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

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

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

@@ -45,7 +45,7 @@ export const documentTemplateSorters: SQLSortDefinitions<DocumentTemplate> = {
     },
     updatedAt: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.updatedAt);
+            return Formatter.dateTimeIso(a.updatedAt, 'UTC');
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
@@ -56,7 +56,7 @@ export const documentTemplateSorters: SQLSortDefinitions<DocumentTemplate> = {
     },
     createdAt: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.createdAt);
+            return Formatter.dateTimeIso(a.createdAt, 'UTC');
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({

package/src/sql-sorters/documents.ts

@@ -34,7 +34,7 @@ export const documentSorters: SQLSortDefinitions<Document> = {
     },
     createdAt: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.createdAt);
+            return Formatter.dateTimeIso(a.createdAt, 'UTC');
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
@@ -45,7 +45,7 @@ export const documentSorters: SQLSortDefinitions<Document> = {
     },
     updatedAt: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.updatedAt);
+            return Formatter.dateTimeIso(a.updatedAt, 'UTC');
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({

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

@@ -1,7 +1,7 @@
 import { SQLResultNamespacedRow } from '@simonbackx/simple-database';
 import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
 import { Formatter } from '@stamhoofd/utility';
-import { organizationJoin } from '../sql-filters/event-notifications';
+import { organizationJoin } from '../sql-filters/event-notifications.js';
 
 export const eventNotificationsSorters: SQLSortDefinitions<SQLResultNamespacedRow> = {
     // WARNING! TEST NEW SORTERS THOROUGHLY!

package/src/sql-sorters/members.ts

@@ -1,8 +1,8 @@
-import { MemberWithRegistrations } from '@stamhoofd/models';
+import { MemberWithUsersRegistrationsAndGroups } from '@stamhoofd/models';
 import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
 import { Formatter } from '@stamhoofd/utility';
 
-export const memberSorters: SQLSortDefinitions<MemberWithRegistrations> = {
+export const memberSorters: SQLSortDefinitions<MemberWithUsersRegistrationsAndGroups> = {
     // 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.

package/src/sql-sorters/orders.ts

@@ -12,7 +12,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
     // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
     createdAt: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.createdAt);
+            return Formatter.dateTimeIso(a.createdAt, 'UTC');
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({
@@ -23,7 +23,7 @@ export const orderSorters: SQLSortDefinitions<Order> = {
     },
     updatedAt: {
         getValue(a) {
-            return Formatter.dateTimeIso(a.updatedAt);
+            return Formatter.dateTimeIso(a.updatedAt, 'UTC');
         },
         toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
             return new SQLOrderBy({