@stamhoofd/backend 2.76.0 → 2.77.1

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.76.0",
+    "version": "2.77.1",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -35,16 +35,16 @@
         "@mollie/api-client": "3.7.0",
         "@simonbackx/simple-database": "1.29.0",
         "@simonbackx/simple-encoding": "2.20.0",
-        "@simonbackx/simple-endpoints": "1.19.0",
+        "@simonbackx/simple-endpoints": "1.19.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.76.0",
-        "@stamhoofd/backend-middleware": "2.76.0",
-        "@stamhoofd/email": "2.76.0",
-        "@stamhoofd/models": "2.76.0",
-        "@stamhoofd/queues": "2.76.0",
-        "@stamhoofd/sql": "2.76.0",
-        "@stamhoofd/structures": "2.76.0",
-        "@stamhoofd/utility": "2.76.0",
+        "@stamhoofd/backend-i18n": "2.77.1",
+        "@stamhoofd/backend-middleware": "2.77.1",
+        "@stamhoofd/email": "2.77.1",
+        "@stamhoofd/models": "2.77.1",
+        "@stamhoofd/queues": "2.77.1",
+        "@stamhoofd/sql": "2.77.1",
+        "@stamhoofd/structures": "2.77.1",
+        "@stamhoofd/utility": "2.77.1",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -64,5 +64,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "85e0625ba777d83d92ad582443df1666955d51f6"
+    "gitHead": "e6d9dce8ddfdfaf5380e98f3a0ffd113a3826955"
 }

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -1,10 +1,9 @@
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { Platform } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
 import { SQL, SQLAlias, SQLCount, SQLDistinct, SQLSelectAs, SQLSum, SQLWhereSign } from '@stamhoofd/sql';
 import { ChargeMembershipsSummary, ChargeMembershipsTypeSummary } from '@stamhoofd/structures';
 import { Context } from '../../../helpers/Context';
-import { QueueHandler } from '@stamhoofd/queues';
-import { Platform } from '@stamhoofd/models';
-import { SimpleError } from '@simonbackx/simple-errors';
 
 type Params = Record<string, never>;
 type Query = Record<string, never>;
@@ -102,6 +101,7 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
             .from('member_platform_memberships')
             .where('balanceItemId', null)
             .where('deletedAt', null)
+            .where('locked', false)
             .whereNot('organizationId', chargeVia);
 
         if (!trial) {
@@ -164,6 +164,7 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
             .from('member_platform_memberships')
             .where('balanceItemId', null)
             .where('deletedAt', null)
+            .where('locked', false)
             .where(trialQ)
             .whereNot('organizationId', chargeVia)
             .groupBy(

package/src/endpoints/global/audit-logs/GetAuditLogsEndpoint.ts

@@ -42,9 +42,18 @@ export class GetAuditLogsEndpoint extends Endpoint<Params, Query, Body, Response
             if (!await Context.auth.hasFullAccess(organization.id)) {
                 throw Context.auth.error();
             }
-            scopeFilter = {
-                organizationId: organization.id,
-            };
+            if (!Context.auth.hasPlatformFullAccess()) {
+                scopeFilter = {
+                    organizationId: organization.id,
+                };
+            } else {
+                if (!q.filter || typeof q.filter !== 'object' || !('objectId' in q.filter)) {
+                    scopeFilter = {
+                        organizationId: organization.id,
+                    };
+                }
+                
+            }
         }
         else {
             if (!Context.auth.hasPlatformFullAccess()) {

package/src/endpoints/global/members/PatchOrganizationMembersEndpoint.ts

@@ -2,8 +2,8 @@ import { OneToManyRelation } from '@simonbackx/simple-database';
 import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, mergeTwoMembers, Organization, Platform, RateLimiter, Registration, RegistrationPeriod, User } from '@stamhoofd/models';
-import { GroupType, MembersBlob, MemberWithRegistrationsBlob, PermissionLevel } from '@stamhoofd/structures';
+import { AuditLog, BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, mergeTwoMembers, Organization, Platform, RateLimiter, Registration, RegistrationPeriod, User } from '@stamhoofd/models';
+import { AuditLogReplacement, AuditLogReplacementType, AuditLogSource, AuditLogType, GroupType, MembersBlob, MemberWithRegistrationsBlob, PermissionLevel } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 
 import { Email } from '@stamhoofd/email';
@@ -17,6 +17,7 @@ import { SetupStepUpdater } from '../../../helpers/SetupStepUpdater';
 import { PlatformMembershipService } from '../../../services/PlatformMembershipService';
 import { RegistrationService } from '../../../services/RegistrationService';
 import { shouldCheckIfMemberIsDuplicateForPatch, shouldCheckIfMemberIsDuplicateForPut } from './shouldCheckIfMemberIsDuplicate';
+import { AuditLogService } from '../../../services/AuditLogService';
 
 type Params = Record<string, never>;
 type Query = undefined;
@@ -532,7 +533,7 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 membership.startDate = new Date(Math.max(Date.now(), put.startDate.getTime()));
                 membership.endDate = put.endDate;
                 membership.expireDate = put.expireDate;
-                membership.locked = put.locked;
+                membership.locked = false;
 
                 await membership.calculatePrice(member);
                 await membership.save();
@@ -540,6 +541,63 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
                 updateMembershipMemberIds.add(member.id);
             }
 
+            for (const p of patch.platformMemberships.getPatches()) {
+                const membership = await MemberPlatformMembership.getByID(p.id);
+
+                if (!membership || membership.memberId !== member.id) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        field: 'id',
+                        message: 'Invalid id',
+                        human: 'Deze aansluiting bestaat niet',
+                    });
+                }
+
+                if (!await Context.auth.hasFullAccess(membership.organizationId)) {
+                    throw Context.auth.error('Je hebt niet voldoende rechten om deze aansluiting aan te passen');
+                }
+
+                if (membership.periodId !== platform.periodId) {
+                    const period = await RegistrationPeriod.getByID(membership.periodId);
+
+                    if (!period) {
+                        throw new SimpleError({
+                            code: 'invalid_field',
+                            message: 'Invalid period',
+                            human: $t(`82af2364-c711-4e44-a871-9346c2cab66a`),
+                            field: 'periodId',
+                        });
+                    }
+
+                    if (period?.locked) {
+                        throw new SimpleError({
+                            code: 'invalid_field',
+                            message: 'Invalid period',
+                            human: $t(`92a41b40-9841-4326-abaf-a8a7d97e5d55`),
+                            field: 'periodId',
+                        });
+                    }
+                }
+
+                // For now only alter 'locked'
+                if (Context.auth.hasPlatformFullAccess()) {
+                    membership.locked = p.locked ?? membership.locked;
+                    await membership.save();
+                }
+                else {
+                    if (p.locked === true) {
+                        throw Context.auth.error($t('bbc639c8-abdb-42d8-b5ed-f58084886ad9'));
+                    }
+
+                    if (p.locked === false) {
+                        throw Context.auth.error($t('c6494677-86f0-4d2e-b9ac-bedfc9e87187'));
+                    }
+                }
+
+                updateMembershipsForOrganizations.add(membership.organizationId); // can influence free memberships in other members of same organization
+                updateMembershipMemberIds.add(member.id);
+            }
+
             // Delete platform memberships
             for (const id of patch.platformMemberships.getDeletes()) {
                 const membership = await MemberPlatformMembership.getByID(id);
@@ -737,6 +795,29 @@ export class PatchOrganizationMembersEndpoint extends Endpoint<Params, Query, Bo
 
             // Grant temporary access to this member without needing to enter the security code again
             await Context.auth.temporarilyGrantMemberAccess(member, PermissionLevel.Write);
+
+            const log = new AuditLog();
+
+            // a member has multiple organizations, so this is difficult to determine - for now it is only visible in the admin panel
+            log.organizationId = member.organizationId; 
+            
+            log.type = AuditLogType.MemberSecurityCodeUsed;
+            log.source = AuditLogSource.Anonymous;
+
+            if (Context.user) {
+                log.userId = Context.user.id;
+                log.source = AuditLogSource.User;
+            }
+
+            log.objectId = member.id;
+            log.replacements = new Map([
+                ['m', AuditLogReplacement.create({
+                    value: member.details.name,
+                    type: AuditLogReplacementType.Member,
+                    id: member.id,
+                })],
+            ]);
+            await log.save();
         }
         else {
             throw new SimpleError({

package/src/endpoints/global/registration/PatchUserMembersEndpoint.test.ts

@@ -0,0 +1,163 @@
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import { Endpoint, Request } from '@simonbackx/simple-endpoints';
+import { GroupFactory, MemberFactory, OrganizationFactory, RegistrationFactory, Token, UserFactory } from '@stamhoofd/models';
+import { MemberDetails, MemberWithRegistrationsBlob, Parent } from '@stamhoofd/structures';
+import { testServer } from '../../../../tests/helpers/TestServer';
+import { PatchUserMembersEndpoint } from './PatchUserMembersEndpoint';
+
+const baseUrl = `/members`;
+const endpoint = new PatchUserMembersEndpoint();
+type EndpointType = typeof endpoint;
+type Body = EndpointType extends Endpoint<any, any, infer B, any> ? B : never;
+
+const firstName = 'John';
+const lastName = 'Doe';
+const birthDay = { year: 1993, month: 4, day: 5 };
+
+const errorWithCode = (code: string) => expect.objectContaining({ code }) as jest.Constructable;
+
+describe('Endpoint.PatchUserMembersEndpoint', () => {
+    describe('Duplicate members', () => {
+        test('The security code should be a requirement', async () => {
+            const organization = await new OrganizationFactory({ }).create();
+            const user = await new UserFactory({ organization }).create();
+            const existingMember = await new MemberFactory({
+                organization,
+                firstName,
+                lastName,
+                birthDay,
+                generateData: true,
+            }).create();
+
+            const token = await Token.createToken(user);
+
+            const arr: Body = new PatchableArray();
+            const put = MemberWithRegistrationsBlob.create({
+                details: MemberDetails.create({
+                    firstName,
+                    lastName,
+                    birthDay: new Date(existingMember.details.birthDay!.getTime() + 1),
+                }),
+            });
+            arr.addPut(put);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+            await expect(testServer.test(endpoint, request))
+                .rejects
+                .toThrow(errorWithCode('known_member_missing_rights'));
+        });
+
+        test('The security code is not a requirement for members without additional data', async () => {
+            const organization = await new OrganizationFactory({ }).create();
+            const user = await new UserFactory({ organization }).create();
+            const existingMember = await new MemberFactory({
+                organization,
+                firstName,
+                lastName,
+                birthDay,
+                generateData: false,
+            }).create();
+
+            const token = await Token.createToken(user);
+
+            const arr: Body = new PatchableArray();
+            const put = MemberWithRegistrationsBlob.create({
+                details: MemberDetails.create({
+                    firstName,
+                    lastName,
+                    birthDay: new Date(existingMember.details.birthDay!.getTime() + 1),
+                    email: 'anewemail@example.com',
+                }),
+            });
+            arr.addPut(put);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+            const response = await testServer.test(endpoint, request);
+            expect(response.status).toBe(200);
+
+            // Check id of the returned memebr matches the existing member
+            expect(response.body.members.length).toBe(1);
+            expect(response.body.members[0].id).toBe(existingMember.id);
+
+            // Check data matches the original data + changes from the put
+            const member = response.body.members[0];
+            expect(member.details.firstName).toBe(firstName);
+            expect(member.details.lastName).toBe(lastName);
+            expect(member.details.birthDay).toEqual(existingMember.details.birthDay);
+            expect(member.details.email).toBe('anewemail@example.com'); // this has been merged
+            expect(member.details.alternativeEmails).toHaveLength(0);
+        });
+
+        test('A duplicate member with existing registrations returns those registrations after a merge', async () => {
+            const organization = await new OrganizationFactory({ }).create();
+            const user = await new UserFactory({ organization }).create();
+            const details = MemberDetails.create({
+                firstName,
+                lastName,
+                securityCode: 'ABC-123',
+                email: 'original@example.com',
+                parents: [
+                    Parent.create({
+                        firstName: 'Jane',
+                        lastName: 'Doe',
+                        email: 'jane.doe@example.com',
+                    }),
+                ],
+            });
+
+            const existingMember = await new MemberFactory({
+                organization,
+                birthDay,
+                details,
+            }).create();
+
+            // Create a registration for this member
+            const group = await new GroupFactory({ organization }).create();
+            const registration = await new RegistrationFactory({
+                member: existingMember,
+                group,
+            }).create();
+
+            const token = await Token.createToken(user);
+
+            const arr: Body = new PatchableArray();
+            const put = MemberWithRegistrationsBlob.create({
+                details: MemberDetails.create({
+                    firstName,
+                    lastName,
+                    birthDay: new Date(existingMember.details.birthDay!.getTime() + 1),
+                    securityCode: existingMember.details.securityCode,
+                    email: 'anewemail@example.com',
+                }),
+            });
+            arr.addPut(put);
+
+            const request = Request.buildJson('PATCH', baseUrl, organization.getApiHost(), arr);
+            request.headers.authorization = 'Bearer ' + token.accessToken;
+            const response = await testServer.test(endpoint, request);
+            expect(response.status).toBe(200);
+
+            // Check id of the returned memebr matches the existing member
+            expect(response.body.members.length).toBe(1);
+            expect(response.body.members[0].id).toBe(existingMember.id);
+
+            // Check data matches the original data + changes from the put
+            const member = response.body.members[0];
+            expect(member.details.firstName).toBe(firstName);
+            expect(member.details.lastName).toBe(lastName);
+            expect(member.details.birthDay).toEqual(existingMember.details.birthDay);
+            expect(member.details.email).toBe('original@example.com'); // this has been merged
+            expect(member.details.alternativeEmails).toEqual(['anewemail@example.com']); // this has been merged
+
+            // Check the registration is still there
+            expect(member.registrations.length).toBe(1);
+            expect(member.registrations[0].id).toBe(registration.id);
+
+            // Check parent is still there
+            expect(member.details.parents.length).toBe(1);
+            expect(member.details.parents[0]).toEqual(existingMember.details.parents[0]);
+        });
+    });
+});

package/src/excel-loaders/payments.ts

@@ -147,6 +147,32 @@ function getBalanceItemColumns(): XlsxTransformerColumn<PaymentWithItem>[] {
                 value: object.balanceItemPayment.balanceItem.description,
             }),
         },
+        {
+            id: 'balanceItem.createdAt',
+            name: 'Aangerekend op',
+            width: 16,
+            getValue: (object: PaymentWithItem) => ({
+                value: object.balanceItemPayment.balanceItem.createdAt,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateTimeSlash,
+                    },
+                },
+            }),
+        },
+        {
+            id: 'balanceItem.dueAt',
+            name: 'Verschuldigd vanaf',
+            width: 16,
+            getValue: (object: PaymentWithItem) => ({
+                value: object.balanceItemPayment.balanceItem.dueAt,
+                style: {
+                    numberFormat: {
+                        id: XlsxBuiltInNumberFormat.DateTimeSlash,
+                    },
+                },
+            }),
+        },
         {
             match: (id) => {
                 if (id.startsWith('balanceItem.relations.')) {

package/src/helpers/AuthenticatedStructures.ts

@@ -1,6 +1,7 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import { AuditLog, BalanceItem, CachedBalance, Document, Event, EventNotification, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, Registration, RegistrationPeriod, Ticket, User, Webshop } from '@stamhoofd/models';
 import { AuditLogReplacement, AuditLogReplacementType, AuditLog as AuditLogStruct, DetailedReceivableBalance, Document as DocumentStruct, EventNotification as EventNotificationStruct, Event as EventStruct, GenericBalance, Group as GroupStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, NamedObject, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, Platform, PrivateOrder, PrivateWebshop, ReceivableBalanceObject, ReceivableBalanceObjectContact, ReceivableBalance as ReceivableBalanceStruct, ReceivableBalanceType, TicketPrivate, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
+import { Sorter } from '@stamhoofd/utility';
 
 import { SQL } from '@stamhoofd/sql';
 import { Formatter } from '@stamhoofd/utility';
@@ -254,7 +255,7 @@ export class AuthenticatedStructures {
                     ...baseStruct,
                     period,
                     privateMeta: organization.privateMeta,
-                    webshops: webshopPreviews.get(organization.id),
+                    webshops: webshopPreviews.get(organization.id)?.sort((a, b) => Sorter.byDateValue(b.createdAt, a.createdAt)),
                 });
             }
             else {

package/src/helpers/MembershipCharger.ts

@@ -35,7 +35,7 @@ export const MembershipCharger = {
                 .where('id', SQLWhereSign.Greater, lastId)
                 .where('balanceItemId', null)
                 .where('deletedAt', null)
-                .whereNot('organizationId', chargeVia)
+                .where('locked', false)
                 .where(SQL.where('trialUntil', null).or('trialUntil', SQLWhereSign.LessEqual, new Date()))
                 .limit(chunkSize)
                 .orderBy(
@@ -66,10 +66,6 @@ export const MembershipCharger = {
                     continue;
                 }
 
-                if (membership.organizationId === chargeVia) {
-                    continue;
-                }
-
                 const member = members.find(m => m.id === membership.memberId);
 
                 if (!member) {
@@ -86,6 +82,15 @@ export const MembershipCharger = {
                     continue;
                 }
 
+                // Lock membership
+                membership.locked = true;
+
+                if (membership.organizationId === chargeVia) {
+                    // Do not charge
+                    await membership.save();
+                    continue;
+                }
+
                 const balanceItem = new BalanceItem();
                 balanceItem.unitPrice = membership.price;
                 balanceItem.amount = 1;

package/src/services/MemberNumberService.ts

@@ -1,7 +1,7 @@
 import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
 import { Member, MemberPlatformMembership, Organization } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import { SQL, SQLWhereLike, scalarToSQLExpression } from '@stamhoofd/sql';
+import { scalarToSQLExpression, SQL, SQLCharLength, SQLWhereLike } from '@stamhoofd/sql';
 
 export class MemberNumberService {
     static async assignMemberNumber(member: Member, membership: MemberPlatformMembership) {
@@ -10,9 +10,20 @@ export class MemberNumberService {
             return;
         }
 
+        if (!STAMHOOFD.MEMBER_NUMBER_ALGORITHM) {
+            console.warn('No member number algorithm set. Please set STAMHOOFD.MEMBER_NUMBER_ALGORITHM in the environment.');
+            return;
+        }
+
         return await QueueHandler.schedule('assignMemberNumber', async function (this: undefined) {
             try {
                 const memberNumber = await MemberNumberService.createMemberNumber(member, membership);
+
+                if (memberNumber === undefined) {
+                    console.warn('No valid member number algorithm set. Please set a valid STAMHOOFD.MEMBER_NUMBER_ALGORITHM in the environment.');
+                    return;
+                }
+
                 member.details.memberNumber = memberNumber;
                 await member.save();
             }
@@ -32,7 +43,16 @@ export class MemberNumberService {
         });
     }
 
-    static async createMemberNumber(member: Member, membership: MemberPlatformMembership): Promise<string> {
+    private static async createMemberNumber(member: Member, membership: MemberPlatformMembership): Promise<string | undefined> {
+        if (STAMHOOFD.MEMBER_NUMBER_ALGORITHM === MemberNumberAlgorithm.Incremental) {
+            return this.createIncrementalMemberNumber();
+        }
+        else if (STAMHOOFD.MEMBER_NUMBER_ALGORITHM === MemberNumberAlgorithm.KSA) {
+            return this.createKSAMemberNumber(member, membership);
+        }
+    }
+
+    private static async createKSAMemberNumber(member: Member, membership: MemberPlatformMembership): Promise<string> {
         // example: 5301-101012-1
 
         // #region get birth date part (ddmmjj)
@@ -117,4 +137,51 @@ export class MemberNumberService {
 
         return memberNumber;
     }
+
+    private static largestMemberNumberCache: number | null = null;
+
+    private static async createIncrementalMemberNumber(): Promise<string> {
+        const requiredLength = STAMHOOFD.MEMBER_NUMBER_ALGORITHM_LENGTH; // Required for reliable sorting (sorting strings with different length will cause unexpected results)
+
+        if (!requiredLength || typeof requiredLength !== 'number') {
+            throw new Error('When using the Incremental member number algorithm, you need to set STAMHOOFD.MEMBER_NUMBER_ALGORITHM_LENGTH in the environment.');
+        }
+
+        let nextNumber = 1;
+
+        if (this.largestMemberNumberCache !== null) {
+            nextNumber = this.largestMemberNumberCache + 1;
+        }
+        else {
+            // Find largest member number in the database
+            // The required length prevents string-sorting with different lengths, causing an unexpected order
+            const query = await SQL.select('memberNumber')
+                .from(SQL.table('members'))
+                .where(
+                    new SQLCharLength(SQL.column('memberNumber')),
+                    requiredLength,
+                )
+                .limit(1)
+                .orderBy('memberNumber', 'DESC')
+                .fetch();
+
+            const largestMemberNumber = query[0]?.['members']?.['memberNumber'];
+
+            if (largestMemberNumber && typeof largestMemberNumber === 'string') {
+                const parsed = parseInt(largestMemberNumber);
+                if (!isNaN(parsed)) {
+                    nextNumber = parsed + 1;
+                }
+            }
+        }
+
+        this.largestMemberNumberCache = nextNumber;
+        const str = nextNumber.toString().padStart(requiredLength, '0');
+
+        if (str.length !== requiredLength) {
+            throw new Error('Reached maximum member number length ' + str);
+        }
+
+        return str;
+    }
 }

package/src/services/SSOService.ts

@@ -613,6 +613,7 @@ export class SSOServiceWithSession {
                 if (!user.lastName || !user.hasPasswordBasedAccount()) {
                     user.lastName = lastName;
                 }
+                user.verified = true;
                 user.linkLoginProvider(this.service.provider, claims.sub, !!this.session.userId);
                 await user.save();
             }

package/src/sql-filters/members.ts

@@ -257,11 +257,13 @@ export const memberFilterCompilers: SQLFilterDefinitions = {
             organizationId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'organizationId')),
             periodId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'periodId')),
             price: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'price')),
-            invoiceId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'invoiceId')),
             startDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'startDate')),
             endDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'endDate')),
             expireDate: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'expireDate')),
             trialUntil: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'trialUntil')),
+            locked: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'locked')),
+            balanceItemId: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'balanceItemId')),
+            generated: createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'generated')),
         },
     ),