@stamhoofd/backend 2.135.0 → 2.136.0

package/src/helpers/MemberMerger.test.ts

@@ -1,10 +1,13 @@
 import {
     Address,
+    BalanceItemRelation,
+    BalanceItemRelationType,
     BooleanStatus,
     EmergencyContact,
     Gender,
     MemberDetails,
     Parent,
+    ReceivableBalanceType,
     RecordAnswer,
     RecordSettings,
     ReviewTime,
@@ -16,8 +19,10 @@ import {
 } from '@stamhoofd/structures';
 import { Country } from '@stamhoofd/types/Country';
 import { v4 as uuidv4 } from 'uuid';
-import { Member } from '@stamhoofd/models';
-import { mergeMemberDetails, selectBaseMember } from './MemberMerger.js';
+import { BalanceItem, BalanceItemFactory, CachedBalance, Member, MemberFactory, OrganizationFactory } from '@stamhoofd/models';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { BalanceItemService } from '../services/BalanceItemService.js';
+import { mergeMemberDetails, mergeTwoMembers, selectBaseMember } from './MemberMerger.js';
 
 describe('member merge', () => {
     describe('mergeMemberDetails', () => {
@@ -914,3 +919,66 @@ describe('member merge', () => {
         });
     });
 });
+
+describe('mergeTwoMembers balance items', () => {
+    beforeEach(() => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    const createBalanceItem = async (organizationId: string, member: Member, unitPrice: number) => {
+        return await new BalanceItemFactory({
+            organizationId,
+            memberId: member.id,
+            amount: 1,
+            unitPrice,
+            relations: new Map([
+                [
+                    BalanceItemRelationType.Member,
+                    BalanceItemRelation.create({
+                        id: member.id,
+                        name: new TranslatedString(member.details.name),
+                    }),
+                ],
+            ]),
+        }).create();
+    };
+
+    test('moves the balance items to the base member, rewrites the Member relation and recalculates cached balances', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const base = await new MemberFactory({ organization, firstName: 'Base', lastName: 'Member' }).create();
+        const other = await new MemberFactory({ organization, firstName: 'Other', lastName: 'Member' }).create();
+
+        const baseItem = await createBalanceItem(organization.id, base, 30_00);
+        const otherItem = await createBalanceItem(organization.id, other, 50_00);
+
+        // Warm up the cached balances so both members have a stale value before merging
+        await CachedBalance.updateForMembers(organization.id, [base.id, other.id]);
+
+        await mergeTwoMembers(base, other);
+
+        // The balance item of the removed member now belongs to the base member
+        const movedItem = await BalanceItem.getByID(otherItem.id);
+        expect(movedItem?.memberId).toBe(base.id);
+
+        // Its Member relation is rewritten to point to the base member
+        const relation = movedItem?.relations.get(BalanceItemRelationType.Member);
+        expect(relation?.id).toBe(base.id);
+        expect(relation?.name.toString()).toBe(base.details.name);
+
+        // The balance item that was already on the base member is untouched
+        const keptItem = await BalanceItem.getByID(baseItem.id);
+        expect(keptItem?.memberId).toBe(base.id);
+        expect(keptItem?.relations.get(BalanceItemRelationType.Member)?.id).toBe(base.id);
+
+        // Make sure all scheduled cached balance updates have run
+        await BalanceItemService.flushAll();
+
+        // The base member now owes both balance items
+        const [baseBalance] = await CachedBalance.getForObjects([base.id], organization.id, ReceivableBalanceType.member);
+        expect(baseBalance?.amountOpen).toBe(80_00);
+
+        // The removed member no longer has an outstanding cached balance
+        const [otherBalance] = await CachedBalance.getForObjects([other.id], organization.id, ReceivableBalanceType.member);
+        expect(otherBalance?.amountOpen ?? 0).toBe(0);
+    });
+});

package/src/helpers/MemberMerger.ts

@@ -19,10 +19,14 @@ import type {
     UitpasNumberDetails,
 } from '@stamhoofd/structures';
 import {
+    BalanceItemRelation,
+    BalanceItemRelationType,
     Gender,
     ParentType,
+    TranslatedString,
 } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
+import { BalanceItemService } from '../services/BalanceItemService.js';
 import { PlatformMembershipService } from '../services/PlatformMembershipService.js';
 import { RegistrationService } from '../services/RegistrationService.js';
 import { MemberUserSyncer } from './MemberUserSyncer.js';
@@ -214,7 +218,45 @@ async function mergeResponsibilities(base: Member, other: Member) {
 }
 
 async function mergeBalanceItems(base: Member, other: Member) {
-    await mergeModels(base, other, BalanceItem);
+    const otherModels = await BalanceItem.select()
+        .where('memberId', other.id)
+        .fetch();
+
+    // Keep track of every organization that had balance items for the removed member,
+    // so we can reset its cached balance afterwards.
+    const organizationIds = new Set<string>();
+
+    for (const otherModel of otherModels) {
+        organizationIds.add(otherModel.organizationId);
+
+        otherModel.memberId = base.id;
+
+        // The Member relation stores the member id + name. Update it so it points to the base member.
+        if (otherModel.relations.has(BalanceItemRelationType.Member) && otherModel.relations.get(BalanceItemRelationType.Member)?.id === other.id) {
+            otherModel.relations.set(
+                BalanceItemRelationType.Member,
+                BalanceItemRelation.create({
+                    id: base.id,
+                    name: new TranslatedString(base.details.name),
+                }),
+            );
+        }
+
+        await otherModel.save({
+            skipMarkSaved: true,
+            skipSendEvents: true,
+        });
+
+        // Recalculate the cached balance of the base member (+ related users/organizations/registrations).
+        // We skip the model events above, so we have to schedule the update manually.
+        BalanceItemService.scheduleUpdate(otherModel);
+    }
+
+    // Recalculate the cached balance of the removed member, otherwise stale amounts remain
+    // in the cached balances for a member that no longer exists.
+    for (const organizationId of organizationIds) {
+        BalanceItemService.scheduleMemberUpdate(organizationId, other.id);
+    }
 }
 
 async function mergeDocuments(base: Member, other: Member) {

package/src/helpers/MemberUserSyncer.ts

@@ -380,6 +380,11 @@ export class MemberUserSyncerStatic {
                         }
                     }
 
+                    if (setMemberId && member.organizationId !== user.organizationId) {
+                        // Don't allow linking across scopes
+                        setMemberId = false;
+                    }
+
                     if (setMemberId) {
                         if (name) {
                             user.firstName = name.firstName;

package/src/helpers/MembershipCharger.test.ts

@@ -0,0 +1,110 @@
+import type { Member, Organization, RegistrationPeriod } from '@stamhoofd/models';
+import { BalanceItem, MemberFactory, MemberPlatformMembership, OrganizationFactory, Platform, RegistrationPeriodFactory } from '@stamhoofd/models';
+import { BalanceItemType, PlatformMembershipType, PlatformMembershipTypeBehaviour, PlatformMembershipTypeConfig, PlatformMembershipTypeConfigPrice, ReduceablePrice } from '@stamhoofd/structures';
+import { TestUtils } from '@stamhoofd/test-utils';
+import { MembershipCharger } from './MembershipCharger.js';
+
+describe('MembershipCharger', () => {
+    const membershipPrice = 25_00;
+
+    let currentPeriod: RegistrationPeriod;
+    let nextPeriod: RegistrationPeriod;
+    let membershipOrganization: Organization;
+    let payingOrganization: Organization;
+    let membershipType: PlatformMembershipType;
+
+    const buildConfig = (period: RegistrationPeriod) => {
+        return PlatformMembershipTypeConfig.create({
+            startDate: period.startDate,
+            endDate: period.endDate,
+            prices: [
+                PlatformMembershipTypeConfigPrice.create({
+                    prices: new Map([['', ReduceablePrice.create({ price: membershipPrice })]]),
+                }),
+            ],
+        });
+    };
+
+    // Set the period that should not be charged yet (or null to charge every period)
+    const setNextPeriod = async (nextPeriodId: string | null) => {
+        const platform = await Platform.getForEditing();
+        platform.periodId = currentPeriod.id;
+        platform.nextPeriodId = nextPeriodId;
+        platform.membershipOrganizationId = membershipOrganization.id;
+        platform.config.membershipTypes = [membershipType];
+        await platform.save();
+    };
+
+    const createMembership = async (period: RegistrationPeriod, organization: Organization, member: Member) => {
+        const membership = new MemberPlatformMembership();
+        membership.memberId = member.id;
+        membership.membershipTypeId = membershipType.id;
+        membership.organizationId = organization.id;
+        membership.periodId = period.id;
+        membership.startDate = period.startDate;
+        membership.endDate = period.endDate;
+        await membership.save();
+        return membership;
+    };
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    beforeAll(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+
+        currentPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2024, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2024, 11, 31, 23, 59, 59, 0),
+        }).create();
+
+        nextPeriod = await new RegistrationPeriodFactory({
+            startDate: new Date(2025, 0, 1, 0, 0, 0, 0),
+            endDate: new Date(2025, 11, 31, 23, 59, 59, 0),
+        }).create();
+
+        membershipOrganization = await new OrganizationFactory({}).create();
+        payingOrganization = await new OrganizationFactory({}).create();
+
+        membershipType = PlatformMembershipType.create({
+            name: 'Test membership',
+            behaviour: PlatformMembershipTypeBehaviour.Period,
+            periods: new Map([
+                [currentPeriod.id, buildConfig(currentPeriod)],
+                [nextPeriod.id, buildConfig(nextPeriod)],
+            ]),
+        });
+    });
+
+    test('Charges current period memberships but skips memberships of the next period', async () => {
+        await setNextPeriod(nextPeriod.id);
+
+        const currentMember = await new MemberFactory({}).create();
+        const nextMember = await new MemberFactory({}).create();
+
+        const currentMembership = await createMembership(currentPeriod, payingOrganization, currentMember);
+        const nextMembership = await createMembership(nextPeriod, payingOrganization, nextMember);
+
+        await MembershipCharger.charge();
+
+        const chargedCurrent = await MemberPlatformMembership.getByID(currentMembership.id);
+        expect(chargedCurrent).toBeDefined();
+        expect(chargedCurrent!.balanceItemId).not.toBeNull();
+        expect(chargedCurrent!.locked).toBe(true);
+
+        // The next period membership should be left untouched
+        const chargedNext = await MemberPlatformMembership.getByID(nextMembership.id);
+        expect(chargedNext).toBeDefined();
+        expect(chargedNext!.balanceItemId).toBeNull();
+        expect(chargedNext!.locked).toBe(false);
+
+        // The created balance item should be charged via the membership organization
+        const balanceItem = await BalanceItem.getByID(chargedCurrent!.balanceItemId!);
+        expect(balanceItem).toBeDefined();
+        expect(balanceItem!.type).toBe(BalanceItemType.PlatformMembership);
+        expect(balanceItem!.unitPrice).toBe(membershipPrice);
+        expect(balanceItem!.organizationId).toBe(membershipOrganization.id);
+        expect(balanceItem!.payingOrganizationId).toBe(payingOrganization.id);
+    });
+});

package/src/helpers/MembershipCharger.ts

@@ -8,10 +8,9 @@ export const MembershipCharger = {
     async charge() {
         console.log('Charging memberships...');
 
-        // Loop all
-        let lastId = '';
         const platform = await Platform.getShared();
         const chargeVia = platform.membershipOrganizationId;
+        const nextPeriodId = platform.nextPeriodId;
 
         if (!chargeVia) {
             throw new SimpleError({
@@ -46,27 +45,17 @@ export const MembershipCharger = {
 
         let createdCount = 0;
         let createdPrice = 0;
-        const chunkSize = 100;
-
-        while (true) {
-            const memberships = await MemberPlatformMembership.select()
-                .where('id', SQLWhereSign.Greater, lastId)
-                .where('deletedAt', null)
-                .where('locked', false)
-                .where(SQL.where('trialUntil', null).or('trialUntil', SQLWhereSign.LessEqual, new Date()))
-                .limit(chunkSize)
-                .orderBy(
-                    new SQLOrderBy({
-                        column: SQL.column('id'),
-                        direction: 'ASC',
-                    }),
-                )
-                .fetch();
+        let q = MemberPlatformMembership.select()
+            .where('deletedAt', null)
+            .where('locked', false)
+            .where(SQL.where('trialUntil', null).or('trialUntil', SQLWhereSign.LessEqual, new Date()));
 
-            if (memberships.length === 0) {
-                break;
-            }
+        if (nextPeriodId) {
+            q = q.where('periodId', '!=', nextPeriodId);
+        }
 
+        // allBatched() paginates by id ASC internally, so we must not set a custom order by here.
+        for await (const memberships of q.limit(100).allBatched()) {
             const memberIds = Formatter.uniqueArray(memberships.map(m => m.memberId));
             const members = await Member.getByIDs(...memberIds);
             const createdBalanceItems: BalanceItem[] = [];
@@ -153,17 +142,6 @@ export const MembershipCharger = {
                 createdCount += 1;
                 createdPrice += membership.price;
             }
-
-            if (memberships.length < chunkSize) {
-                break;
-            }
-
-            const z = lastId;
-            lastId = memberships[memberships.length - 1].id;
-
-            if (lastId === z) {
-                throw new Error('Unexpected infinite loop found in MembershipCharger');
-            }
         }
 
         console.log('Charged ' + Formatter.integer(createdCount) + '  memberships, for a total value of ' + Formatter.price(createdPrice));

package/src/helpers/XlsxTransformerColumnHelper.test.ts

@@ -1,6 +1,7 @@
 import type { XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
 import type { PlatformMember } from '@stamhoofd/structures';
 import {
+    EmergencyContact,
     Group,
     GroupCategory,
     GroupCategorySettings,
@@ -166,4 +167,66 @@ describe('XlsxTransformerColumnHelper', () => {
             expect(getColumn(ageGroupsCategory.id).getValue(member).value).toBe('Kapoenen, Welpen');
         });
     });
+
+    describe('createColumnsForEmergencyContacts', () => {
+        function createMember(emergencyContacts: EmergencyContact[]) {
+            const organization = Organization.create({});
+            const blob = MembersBlob.create({
+                organizations: [organization],
+                members: [
+                    MemberWithRegistrationsBlob.create({
+                        details: MemberDetails.create({ firstName: 'John', lastName: 'Doe', emergencyContacts }),
+                    }),
+                ],
+            });
+
+            const family = PlatformFamily.create(blob, { platform: Platform.create({}), contextOrganization: organization });
+            return family.members[0];
+        }
+
+        function getValue(member: PlatformMember, id: string) {
+            const columns = XlsxTransformerColumnHelper.createColumnsForEmergencyContacts();
+            const column = columns.find(c => 'id' in c && c.id === id) as XlsxTransformerConcreteColumn<PlatformMember> | undefined;
+
+            if (!column) {
+                throw new Error(`Column ${id} not found`);
+            }
+
+            return column.getValue(member).value;
+        }
+
+        it('returns the values of the first two emergency contacts', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: '0470 12 34 56' }),
+                EmergencyContact.create({ name: 'Jan Janssens', title: 'Buur', phone: '0470 65 43 21' }),
+            ]);
+
+            expect(getValue(member, 'emergencyContact.0.name')).toBe('An Peeters');
+            expect(getValue(member, 'emergencyContact.0.title')).toBe('Oma');
+            expect(getValue(member, 'emergencyContact.0.phone')).toBe('0470 12 34 56');
+
+            expect(getValue(member, 'emergencyContact.1.name')).toBe('Jan Janssens');
+            expect(getValue(member, 'emergencyContact.1.title')).toBe('Buur');
+            expect(getValue(member, 'emergencyContact.1.phone')).toBe('0470 65 43 21');
+        });
+
+        it('returns empty values when the member has fewer emergency contacts', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: '0470 12 34 56' }),
+            ]);
+
+            expect(getValue(member, 'emergencyContact.1.name')).toBe('');
+            expect(getValue(member, 'emergencyContact.1.title')).toBe('');
+            expect(getValue(member, 'emergencyContact.1.phone')).toBe('');
+        });
+
+        it('returns an empty value for a contact without a phone number', () => {
+            const member = createMember([
+                EmergencyContact.create({ name: 'An Peeters', title: 'Oma', phone: null }),
+            ]);
+
+            expect(getValue(member, 'emergencyContact.0.name')).toBe('An Peeters');
+            expect(getValue(member, 'emergencyContact.0.phone')).toBe('');
+        });
+    });
 });

package/src/helpers/XlsxTransformerColumnHelper.ts

@@ -1,6 +1,6 @@
 import type { XlsxTransformerColumn, XlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
 import { isXlsxTransformerConcreteColumn } from '@stamhoofd/excel-writer';
-import type { Address, GroupCategory, Parent, PlatformMember, RecordAnswer, RecordSettings } from '@stamhoofd/structures';
+import type { Address, EmergencyContact, GroupCategory, Parent, PlatformMember, RecordAnswer, RecordSettings } from '@stamhoofd/structures';
 import { CountryHelper, ParentTypeHelper, RecordCategory, RecordType } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
@@ -24,6 +24,52 @@ export class XlsxTransformerColumnHelper {
         ];
     }
 
+    /**
+     * Emergency contacts are an unbounded array, so only the first two get their own columns. The combined
+     * 'emergencyContacts' column in the members loader lists all of them.
+     */
+    static createColumnsForEmergencyContacts(): XlsxTransformerColumn<PlatformMember>[] {
+        return [
+            ...this.createColumnsForEmergencyContact(0),
+            ...this.createColumnsForEmergencyContact(1),
+        ];
+    }
+
+    static createColumnsForEmergencyContact(contactIndex: number): XlsxTransformerColumn<PlatformMember>[] {
+        const getContact = (member: PlatformMember): EmergencyContact | null | undefined => member.patchedMember.details.emergencyContacts[contactIndex];
+
+        const identifier = `Noodcontact ${contactIndex + 1}`;
+        const getId = (value: string) => `emergencyContact.${contactIndex}.${value}`;
+        const getName = (value: string) => `${identifier} - ${value}`;
+
+        return [
+            {
+                id: getId('name'),
+                name: getName($t(`%1Os`)),
+                width: 20,
+                getValue: (member: PlatformMember) => ({
+                    value: getContact(member)?.name ?? '',
+                }),
+            },
+            {
+                id: getId('title'),
+                name: getName($t(`%f5`)),
+                width: 20,
+                getValue: (member: PlatformMember) => ({
+                    value: getContact(member)?.title ?? '',
+                }),
+            },
+            {
+                id: getId('phone'),
+                name: getName($t(`%wD`)),
+                width: 20,
+                getValue: (member: PlatformMember) => ({
+                    value: getContact(member)?.phone ?? '',
+                }),
+            },
+        ];
+    }
+
     static createColumnsForAddresses<T>({ limit, getAddresses, matchIdStart }: { limit: number; getAddresses: (object: T) => Address[]; matchIdStart: string }): XlsxTransformerColumn<T>[] {
         const result: XlsxTransformerColumn<unknown>[] = [];
 

package/src/seeds/1784057557-fix-invisible-trial-registrations.ts

@@ -0,0 +1,143 @@
+import { Migration } from '@simonbackx/simple-database';
+import { BalanceItem, Organization, Registration } from '@stamhoofd/models';
+import { QueryableModel } from '@stamhoofd/sql';
+import { BalanceItemStatus } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { SeedTools } from '../helpers/SeedTools.js';
+import { BalanceItemService } from '../services/BalanceItemService.js';
+
+/**
+ * Registrations with a trial period that were made via the member portal were never activated: their
+ * balance items are only due after the trial, so they were not part of the payment, and nothing ever
+ * marked them valid. The result is a registration that exists in the database, but is invisible in the
+ * registration lists and the member portal, and a balance item that stays Hidden and is never billed.
+ *
+ * markPaid (without a payment) puts them in the exact same state as a registration made after the fix:
+ * it marks the balance item due (Hidden -> Due) and marks the registration valid without shortening the
+ * trial period.
+ */
+export async function fixInvisibleTrialRegistrations() {
+    let fixed = 0;
+    let skipped = 0;
+    let expired = 0;
+
+    const now = new Date();
+
+    const result = await SeedTools.loopBatched({
+        // Keyset pagination on id: activating a registration drops it from this filter, but rows are
+        // never skipped because each next batch is fetched by id > lastId.
+        //
+        // For now, only registrations whose trial is still running are activated. Activating one whose
+        // trial already ended would mark its balance item due right away (its dueAt is in the past), so
+        // the member would immediately owe the full price - as an overdue amount - for a trial they
+        // never got, since the registration was invisible to them the whole time. Most of the affected
+        // registrations are in that state, so this deliberately does not fix all of them yet: what
+        // should happen to them (bill them anyway, give them a new payment deadline, or don't charge
+        // them at all) is still to be decided. Leaving them untouched keeps that decision open, no data
+        // is lost and a later seed can still pick them up.
+        query: Registration.select()
+            .whereNot('trialUntil', null)
+            .where('registeredAt', null)
+            .where('deactivatedAt', null),
+        batchSize: 100,
+        batchAction: async (registrations: Registration[]) => {
+            const organizationIds = Formatter.uniqueArray(registrations.map(r => r.organizationId));
+            const organizations = organizationIds.length ? await Organization.getByIDs(...organizationIds) : [];
+
+            for (const registration of registrations) {
+                try {
+                    const organization = organizations.find(o => o.id === registration.organizationId);
+                    if (!organization) {
+                        console.warn('Organization not found for registration, skipping', registration.id, registration.organizationId);
+                        skipped++;
+                        continue;
+                    }
+
+                    // The trial already ended. Activating it now would mark the balance item due right
+                    // away (its dueAt is in the past), so the member would immediately owe the full
+                    // price for a trial they never got. Leave it alone.
+                    if (registration.trialUntil === null || registration.trialUntil <= now) {
+                        expired++;
+                        continue;
+                    }
+
+                    // The registration was invisible, so the member may have been registered for the same
+                    // group again in the meantime. Activating this one would create a duplicate.
+                    const activeDuplicates = await Registration.select()
+                        .where('memberId', registration.memberId)
+                        .where('groupId', registration.groupId)
+                        .where('periodId', registration.periodId)
+                        .whereNot('registeredAt', null)
+                        .where('deactivatedAt', null)
+                        .count();
+
+                    if (activeDuplicates > 0) {
+                        console.log('Member is already registered for this group again, skipping', registration.id);
+                        skipped++;
+                        continue;
+                    }
+
+                    // Do not send a registration confirmation email for a registration that was made a
+                    // long time ago. The flag is only read when the registration is marked valid.
+                    if (registration.sendConfirmationEmail) {
+                        registration.sendConfirmationEmail = false;
+                        await registration.save();
+                    }
+
+                    // All the balance items of a trial registration are deferred (Hidden + dueAt), so they
+                    // all need to be marked due. The base and option items also mark the registration valid.
+                    const balanceItems = await BalanceItem.select()
+                        .where('registrationId', registration.id)
+                        .where('status', BalanceItemStatus.Hidden)
+                        .fetch();
+
+                    for (const balanceItem of balanceItems) {
+                        await BalanceItemService.markPaid(balanceItem, null, organization);
+                    }
+
+                    // A trial registration always has at least one balance item, but don't leave the
+                    // registration invisible if it somehow doesn't.
+                    await registration.refresh();
+                    if (registration.registeredAt === null) {
+                        console.warn('Registration has no hidden balance items to activate it, skipping', registration.id);
+                        skipped++;
+                        continue;
+                    }
+
+                    // markValid stamps registeredAt with the current date. Attribute the registration to
+                    // the date it was really made instead of the date this migration runs.
+                    registration.registeredAt = registration.createdAt;
+                    await registration.save();
+
+                    fixed++;
+                } catch (e) {
+                    // Isolate failures per registration: one bad row should not abort (and wedge) the whole migration.
+                    console.error('Failed to fix trial registration, skipping', registration.id, e);
+                    skipped++;
+                }
+
+                if (QueryableModel.shutdownMigrations) {
+                    break;
+                }
+            }
+
+            if (QueryableModel.shutdownMigrations) {
+                throw new Error('Stopping migration gracefully');
+            }
+        },
+    });
+
+    console.log(`Finished fixing invisible trial registrations: ${fixed} fixed, ${expired} left alone because their trial already ended, ${skipped} skipped of ${result.total} registrations.`);
+
+    return { fixed, skipped, expired };
+}
+
+export default new Migration(async () => {
+    if (STAMHOOFD.environment === 'test') {
+        console.log('skipped in tests');
+        return;
+    }
+
+    console.log('Start fixing invisible trial registrations.');
+    await fixInvisibleTrialRegistrations();
+});

package/src/services/BalanceItemService.ts

@@ -189,7 +189,7 @@ export class BalanceItemService {
         userUpdateQueue.addItem(organizationId, userId);
     }
 
-    static cheduleMemberUpdate(organizationId: string, memberId: string) {
+    static scheduleMemberUpdate(organizationId: string, memberId: string) {
         memberUpdateQueue.addItem(organizationId, memberId);
     }
 

package/src/sql-filters/members.ts

@@ -509,6 +509,11 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
                     type: SQLValueType.JSONScalar, // Can be string, number or boolean
                     nullable: true,
                 }),
+                dateValue: createColumnFilter({
+                    expression: SQL.jsonExtract(SQL.column('details'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.dateValue`, true),
+                    type: SQLValueType.JSONDate,
+                    nullable: true,
+                }),
             }),
             {
                 checkPermission: async (key: string) => {

package/src/sql-filters/orders.ts

@@ -216,6 +216,11 @@ export const orderFilterCompilers: SQLFilterDefinitions = {
                 type: SQLValueType.JSONScalar, // Can be string, number or boolean
                 nullable: true,
             }),
+            dateValue: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('data'), `$.value.recordAnswers.${SQLJsonExtract.escapePathComponent(key)}.dateValue`, true),
+                type: SQLValueType.JSONDate,
+                nullable: true,
+            }),
         }),
     ),
     payments: createExistsFilter(

package/vitest.config.js

@@ -2,6 +2,7 @@ import { defineConfig } from 'vitest/config';
 
 export default defineConfig({
     test: {
+        include: ['**/*.test.ts'], // only match TypeScript sources, so compiled copies in dist are never picked up
         globalSetup: './tests/vitest.global.setup.ts',
         setupFiles: ['./tests/vitest.setup.ts'],
         watch: false,