@stamhoofd/backend 2.119.0 → 2.120.0

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

@@ -1,7 +1,8 @@
 import { PatchMap } from '@simonbackx/simple-encoding';
 import { Request } from '@simonbackx/simple-endpoints';
 import { EmailMocker } from '@stamhoofd/email';
-import { BalanceItemFactory, Group, GroupFactory, Member, MemberFactory, MemberWithUsersRegistrationsAndGroups, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
+import type { MemberWithUsersRegistrationsAndGroups, Organization, RegistrationPeriod} from '@stamhoofd/models';
+import { BalanceItemFactory, Group, GroupFactory, Member, MemberFactory, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { AccessRight, BalanceItemCartItem, BalanceItemStatus, BalanceItemType, BooleanStatus, Company, GroupOption, GroupOptionMenu, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, OrganizationPackages, PaymentCustomer, PaymentMethod, PermissionLevel, Permissions, PermissionsResourceType, ReduceablePrice, RegisterItemOption, ResourcePermissions, STPackageStatus, STPackageType, UitpasNumberDetails, UitpasSocialTariff, UitpasSocialTariffStatus, UserPermissions, Version } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { v4 as uuidv4 } from 'uuid';
@@ -46,8 +47,8 @@ describe('Endpoint.RegisterMembers', () => {
     });
 
     afterEach(() => {
-        jest.restoreAllMocks();
-        jest.useRealTimers();
+        vitest.restoreAllMocks();
+        vitest.useRealTimers();
     });
 
     const initOrganization = async (registrationPeriod: RegistrationPeriod = period) => {
@@ -274,9 +275,9 @@ describe('Endpoint.RegisterMembers', () => {
 
             await balanceItem1.delete();
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Oeps, één of meerdere openstaande bedragen in jouw winkelmandje zijn aangepast'));
+                .toThrow('Oeps, één of meerdere openstaande bedragen in jouw winkelmandje zijn aangepast');
         });
 
         test('Should fail if balance item price difference', async () => {
@@ -348,9 +349,9 @@ describe('Endpoint.RegisterMembers', () => {
             // #endregion
 
             // #region act and assert
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Member not found'));
+                .toThrow('Member not found');
             // #endregion
         });
 
@@ -387,9 +388,9 @@ describe('Endpoint.RegisterMembers', () => {
             // #region act and assert
             await balanceItem1.delete();
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Oeps, jouw mandje is leeg.'));
+                .toThrow('Oeps, jouw mandje is leeg.');
             // #endregion
         });
 
@@ -418,7 +419,7 @@ describe('Endpoint.RegisterMembers', () => {
                 customer: null,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
                 .toThrow(STExpect.simpleError({ code: 'changed_price' }));
         });
@@ -454,7 +455,7 @@ describe('Endpoint.RegisterMembers', () => {
             await post(body, organization, token);
 
             // second time should fail
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
                 .toThrow(STExpect.simpleError({ code: 'already_registered' }));
         });
@@ -492,7 +493,7 @@ describe('Endpoint.RegisterMembers', () => {
                 customer: null,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
                 .toThrow(STExpect.simpleErrors([
                     { code: 'duplicate_register_item' },
@@ -530,9 +531,9 @@ describe('Endpoint.RegisterMembers', () => {
             // #endregion
 
             // #region act and assert
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Oeps, je hebt geen geldige betaalmethode geselecteerd'));
+                .toThrow('Oeps, je hebt geen geldige betaalmethode geselecteerd');
             // #endregion
         });
 
@@ -569,9 +570,9 @@ describe('Endpoint.RegisterMembers', () => {
             // #endregion
 
             // #region act and assert
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('redirectUrl or cancelUrl is missing'));
+                .toThrow('redirectUrl or cancelUrl is missing');
             // #endregion
         });
 
@@ -602,9 +603,9 @@ describe('Endpoint.RegisterMembers', () => {
                 customer: null,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('redirectUrl or cancelUrl is missing'));
+                .toThrow('redirectUrl or cancelUrl is missing');
         });
 
         test('Should not reserve for point of sale payment method if group has max members', async () => {
@@ -880,7 +881,7 @@ describe('Endpoint.RegisterMembers', () => {
         test('Register for group with trial should set trial period', async () => {
             // #region arrange
             const date = new Date('2023-05-14');
-            jest.useFakeTimers({ advanceTimers: true, doNotFake: ['setTimeout', 'clearTimeout', 'hrtime', 'nextTick', 'performance', 'queueMicrotask', 'setImmediate', 'clearImmediate'] }).setSystemTime(date);
+            vitest.useFakeTimers({ shouldAdvanceTime: true, toFake: ['Date'] }).setSystemTime(date);
 
             try {
                 const { member, group, groupPrice, organization, token } = await initData();
@@ -926,7 +927,7 @@ describe('Endpoint.RegisterMembers', () => {
                 expect(trialUntil!.getDate()).toBe(19);
             }
             finally {
-                jest.useRealTimers();
+                vitest.useRealTimers();
             }
         }, 20_00000);
 
@@ -1013,9 +1014,9 @@ describe('Endpoint.RegisterMembers', () => {
             // #region act and assert
             expect(group?.stockReservations.length).toBe(0);
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Maximum reached'));
+                .toThrow('Maximum reached');
             // #endregion
         });
 
@@ -1090,9 +1091,9 @@ describe('Endpoint.RegisterMembers', () => {
             // #endregion
 
             // #region act and assert
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Stock empty'));
+                .toThrow('Stock empty');
             // #endregion
         });
 
@@ -1168,9 +1169,9 @@ describe('Endpoint.RegisterMembers', () => {
                 customer: null,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Option maximum exceeded'));
+                .toThrow('Option maximum exceeded');
         });
 
         test('Should not fail if max option not exceeded', async () => {
@@ -1295,7 +1296,7 @@ describe('Endpoint.RegisterMembers', () => {
                 // act
 
                 // should throw error
-                await expect(async () => await post(body, organization, token))
+                await expect(post(body, organization, token))
                     .rejects
                     .toThrow(STExpect.errorWithCode('changed_price'));
 
@@ -2005,7 +2006,7 @@ describe('Endpoint.RegisterMembers', () => {
             });
 
             // send request and check occupancy
-            await expect(async () => await post(body, organization, token)).rejects.toThrow('No permission to register in this group');
+            await expect(post(body, organization, token)).rejects.toThrow('No permission to register in this group');
         });
 
         test('Cannot register a member with only read permissions even when having full permissions to the specific member', async () => {
@@ -2041,7 +2042,7 @@ describe('Endpoint.RegisterMembers', () => {
             });
 
             // send request and check occupancy
-            await expect(async () => await post(body, organization, token)).rejects.toThrow('No permission to register in this group');
+            await expect(post(body, organization, token)).rejects.toThrow('No permission to register in this group');
         });
     });
 
@@ -2165,7 +2166,7 @@ describe('Endpoint.RegisterMembers', () => {
                 asOrganizationId: organization2.id,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
                 .toThrow(STExpect.simpleError({ code: 'forbidden' }));
         });
@@ -2201,7 +2202,7 @@ describe('Endpoint.RegisterMembers', () => {
                 asOrganizationId: organization2.id,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
                 .toThrow(STExpect.simpleError({ code: 'as_organization_disabled' }));
         });
@@ -2234,9 +2235,9 @@ describe('Endpoint.RegisterMembers', () => {
                 asOrganizationId: organization2.id,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('customer is required when paying as an organization'));
+                .toThrow('customer is required when paying as an organization');
         });
 
         test('Deleting registrations is not allowed', async () => {
@@ -2272,7 +2273,7 @@ describe('Endpoint.RegisterMembers', () => {
                 customer: null,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
                 .toThrow(STExpect.simpleError({ code: 'forbidden' }));
         });
@@ -2307,9 +2308,9 @@ describe('Endpoint.RegisterMembers', () => {
                 asOrganizationId: organization2.id,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('customer.company is required'));
+                .toThrow('customer.company is required');
         });
 
         test('Should fail if company does not exist on organization', async () => {
@@ -2344,9 +2345,9 @@ describe('Endpoint.RegisterMembers', () => {
                 asOrganizationId: organization2.id,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Oeps, de facturatiegegevens die je probeerde te selecteren lijken niet meer te bestaan.'));
+                .toThrow('Oeps, de facturatiegegevens die je probeerde te selecteren lijken niet meer te bestaan.');
         });
     });
 
@@ -2609,9 +2610,9 @@ describe('Endpoint.RegisterMembers', () => {
             // #endregion
 
             // #region act and assert
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Registration not found'));
+                .toThrow('Registration not found');
             // #endregion
         });
 
@@ -2660,7 +2661,7 @@ describe('Endpoint.RegisterMembers', () => {
             });
 
             // send request and check occupancy
-            await expect(async () => await post(body, organization, token)).rejects.toThrow('Not allowed to move registrations');
+            await expect(post(body, organization, token)).rejects.toThrow('Not allowed to move registrations');
         });
     });
 
@@ -2783,7 +2784,7 @@ describe('Endpoint.RegisterMembers', () => {
                 customer: null,
             });
 
-            await expect(async () => await post(body, organization1, token)).rejects.toThrow('Permission denied: you are not allowed to delete registrations');
+            await expect(post(body, organization1, token)).rejects.toThrow('Permission denied: you are not allowed to delete registrations');
         });
 
         test('Should deactivate registration', async () => {
@@ -2936,7 +2937,7 @@ describe('Endpoint.RegisterMembers', () => {
                     customer: null,
                 });
 
-                await expect(async () => await post(body2, organization, token))
+                await expect(post(body2, organization, token))
                     .rejects
                     .toThrow(STExpect.simpleError({
                         field: 'cancellationFeePercentage',
@@ -2987,9 +2988,9 @@ describe('Endpoint.RegisterMembers', () => {
                 customer: null,
             });
 
-            await expect(async () => await post(body, organization, token))
+            await expect(post(body, organization, token))
                 .rejects
-                .toThrow(new RegExp('Permission denied: you are not allowed to delete registrations'));
+                .toThrow('Permission denied: you are not allowed to delete registrations');
         });
 
         test('Cannot delete registrations as admin if no write permission to group', async () => {
@@ -3020,7 +3021,7 @@ describe('Endpoint.RegisterMembers', () => {
                 asOrganizationId: organization.id,
             });
 
-            await expect(async () => await post(body, organization, token)).rejects.toThrow(/No permission to delete this registration/);
+            await expect(post(body, organization, token)).rejects.toThrow(/No permission to delete this registration/);
         });
 
         /**
@@ -3052,7 +3053,7 @@ describe('Endpoint.RegisterMembers', () => {
                 asOrganizationId: organization.id,
             });
 
-            await expect(async () => await post(body, organization, token)).rejects.toThrow(/No permission to delete this registration/);
+            await expect(post(body, organization, token)).rejects.toThrow(/No permission to delete this registration/);
         });
 
         test('Should fail if registration does not exist anymore', async () => {
@@ -3100,7 +3101,7 @@ describe('Endpoint.RegisterMembers', () => {
 
             // #region act and assert
             await registration.delete();
-            await expect(async () => await post(body, organization, token)).rejects.toThrow(new RegExp('Registration not found'));
+            await expect(post(body, organization, token)).rejects.toThrow('Registration not found');
             // #endregion
         });
 
@@ -3181,7 +3182,7 @@ describe('Endpoint.RegisterMembers', () => {
 
             // #region act and assert
             await post(body1, organization, token);
-            await expect(async () => await post(body2, organization, token)).rejects.toThrow(/No permission to delete this registration/);
+            await expect(post(body2, organization, token)).rejects.toThrow(/No permission to delete this registration/);
             // #endregion
         });
     });

package/src/endpoints/global/registration/RegisterMembersEndpoint.ts

@@ -1,11 +1,14 @@
 import { createMollieClient, PaymentMethod as molliePaymentMethod } from '@mollie/api-client';
 import { ManyToOneRelation } from '@simonbackx/simple-database';
-import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { Decoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Email } from '@stamhoofd/email';
-import { BalanceItem, BalanceItemPayment, CachedBalance, Group, Member, MemberWithUsersRegistrationsAndGroups, MolliePayment, MollieToken, Organization, PayconiqPayment, Payment, Platform, RateLimiter, Registration, User } from '@stamhoofd/models';
-import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItem as BalanceItemStruct, BalanceItemType, IDRegisterCheckout, PaymentCustomer, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PaymentType, PermissionLevel, PlatformFamily, PlatformMember, ReceivableBalanceType, RegisterItem, RegisterResponse, TranslatedString, Version } from '@stamhoofd/structures';
+import type { MemberWithUsersRegistrationsAndGroups, Organization, Payment} from '@stamhoofd/models';
+import { BalanceItem, BalanceItemPayment, CachedBalance, Group, Member, MolliePayment, MollieToken, PayconiqPayment, Platform, RateLimiter, Registration, User } from '@stamhoofd/models';
+import type { BalanceItem as BalanceItemStruct, PlatformMember, RegisterItem} from '@stamhoofd/structures';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, IDRegisterCheckout, PaymentCustomer, PaymentMethod, PaymentMethodHelper, PaymentProvider, PaymentStatus, Payment as PaymentStruct, PaymentType, PermissionLevel, PlatformFamily, ReceivableBalanceType, RegisterResponse, TranslatedString, Version } from '@stamhoofd/structures';
 import { Formatter, sleep } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures.js';

package/src/endpoints/global/registration-periods/GetRegistrationPeriodsEndpoint.ts

@@ -1,10 +1,13 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, PaginatedResponse, RegistrationPeriod as RegistrationPeriodStruct, StamhoofdFilter } from '@stamhoofd/structures';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import type { CountFilteredRequest, RegistrationPeriod as RegistrationPeriodStruct, StamhoofdFilter } from '@stamhoofd/structures';
+import { assertSort, getSortFilter, LimitedFilteredRequest, PaginatedResponse } from '@stamhoofd/structures';
 
-import { Decoder } from '@simonbackx/simple-encoding';
+import type { Decoder } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { RegistrationPeriod } from '@stamhoofd/models';
-import { applySQLSorter, compileToSQLFilter, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import type { SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { Context } from '../../../helpers/Context.js';
 import { registrationPeriodFilterCompilers } from '../../../sql-filters/registration-periods.js';
 import { registrationPeriodSorters } from '../../../sql-sorters/registration-periods.js';

package/src/endpoints/global/registration-periods/PatchRegistrationPeriodsEndpoint.ts

@@ -1,5 +1,7 @@
-import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder, patchObject } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder} from '@simonbackx/simple-encoding';
+import { PatchableArrayDecoder, StringDecoder, patchObject } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { RegistrationPeriod as RegistrationPeriodStruct } from '@stamhoofd/structures';
 
 import { SimpleError } from '@simonbackx/simple-errors';

package/src/endpoints/global/sso/GetSSOEndpoint.ts

@@ -1,9 +1,11 @@
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { LoginProviderType, OpenIDClientConfiguration } from '@stamhoofd/structures';
 
 import { Context } from '../../../helpers/Context.js';
 import { Platform } from '@stamhoofd/models';
-import { AutoEncoder, Decoder, EnumDecoder, field } from '@simonbackx/simple-encoding';
+import type { Decoder} from '@simonbackx/simple-encoding';
+import { AutoEncoder, EnumDecoder, field } from '@simonbackx/simple-encoding';
 import { SSOService } from '../../../services/SSOService.js';
 
 type Params = Record<string, never>;

package/src/endpoints/global/sso/SetSSOEndpoint.ts

@@ -1,5 +1,6 @@
-import { AutoEncoderPatchType, Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { AutoEncoderPatchType, Decoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { OpenIDClientConfiguration } from '@stamhoofd/structures';
 
 import { Context } from '../../../helpers/Context.js';

package/src/endpoints/global/webshops/GetWebshopFromDomainEndpoint.ts

@@ -1,5 +1,7 @@
-import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import type { Decoder} from '@simonbackx/simple-encoding';
+import { AutoEncoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Organization } from '@stamhoofd/models';
 import { Webshop } from '@stamhoofd/models';

package/src/endpoints/global/webshops/GetWebshopsCountEndpoint.ts

@@ -0,0 +1,43 @@
+import type { Decoder } from '@simonbackx/simple-encoding';
+import type { DecodedRequest, Request } from '@simonbackx/simple-endpoints';
+import { Endpoint, Response } from '@simonbackx/simple-endpoints';
+import { CountFilteredRequest, CountResponse } from '@stamhoofd/structures';
+
+import { Context } from '../../../helpers/Context.js';
+import { GetWebshopsEndpoint } from './GetWebshopsEndpoint.js';
+
+type Params = Record<string, never>;
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetWebshopsCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/webshops/count', {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOptionalOrganizationScope();
+        await Context.authenticate();
+
+        const query = await GetWebshopsEndpoint.buildQuery(request.query);
+        const count = await query.count();
+
+        return new Response(
+            CountResponse.create({
+                count,
+            }),
+        );
+    }
+}