@stamhoofd/backend 2.83.4 → 2.84.0

package/src/sql-sorters/registrations.ts

@@ -0,0 +1,77 @@
+import { Member } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { RegistrationWithMemberBlob } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { memberJoin } from '../sql-filters/registrations';
+
+export const registrationSorters: SQLSortDefinitions<RegistrationWithMemberBlob> = {
+    // 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,
+            });
+        },
+    },
+    'registeredAt': {
+        getValue(a) {
+            return a.registeredAt;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('registeredAt'),
+                direction,
+            });
+        },
+    },
+    'member.firstName': {
+        getValue(a) {
+            return a.member.firstName;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column(Member.table, 'firstName'),
+                direction,
+            });
+        },
+        join: memberJoin,
+        select: [SQL.column(Member.table, 'firstName')],
+    },
+    'member.lastName': {
+        getValue(a) {
+            return a.member.lastName;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column(Member.table, 'lastName'),
+                direction,
+            });
+        },
+        join: memberJoin,
+        select: [SQL.column(Member.table, 'lastName')],
+    },
+    'member.birthDay': {
+        getValue(a) {
+            return a.member.details.birthDay === null ? null : Formatter.dateIso(a.member.details.birthDay as Date);
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column(Member.table, 'birthDay'),
+                direction,
+            });
+        },
+        join: memberJoin,
+        select: [SQL.column(Member.table, 'birthDay')],
+    },
+};

package/tests/actions/patchOrganizationMember.ts

@@ -0,0 +1,27 @@
+import { AutoEncoderPatchType, PatchableArray } from '@simonbackx/simple-encoding';
+import { Request } from '@simonbackx/simple-endpoints';
+import { Organization } from '@stamhoofd/models';
+import { MemberWithRegistrationsBlob } from '@stamhoofd/structures';
+import { PatchOrganizationMembersEndpoint } from '../../src/endpoints/global/members/PatchOrganizationMembersEndpoint';
+import { testServer } from '../helpers/TestServer';
+import { initAdmin } from '../init/initAdmin';
+
+export async function patchOrganizationMember({ patch, organization }: { patch: AutoEncoderPatchType<MemberWithRegistrationsBlob>; organization: Organization }) {
+    expect(patch.id).toBeString();
+    const { adminToken } = await initAdmin({ organization: organization });
+
+    const arr = new PatchableArray();
+    arr.addPatch(patch);
+
+    const request = Request.patch({
+        path: '/organization/members',
+        host: organization.getApiHost(),
+        body: arr,
+        headers: {
+            authorization: 'Bearer ' + adminToken.accessToken,
+        },
+    });
+
+    const response = await testServer.test(new PatchOrganizationMembersEndpoint(), request);
+    expect(response.status).toBe(200);
+}

package/tests/actions/patchPaymentStatus.ts

@@ -0,0 +1,45 @@
+import { PatchableArray } from '@simonbackx/simple-encoding';
+import { PaymentStatus, PaymentGeneral } from '@stamhoofd/structures';
+import { PatchPaymentsEndpoint } from '../../src/endpoints/organization/dashboard/payments/PatchPaymentsEndpoint';
+import { testServer } from '../helpers/TestServer';
+import { Request } from '@simonbackx/simple-endpoints';
+import { Organization } from '@stamhoofd/models';
+import { initAdmin } from '../init/initAdmin';
+
+export async function changePaymentStatus({ payment, organization, status }: { payment: { id: string }; organization: Organization; status: PaymentStatus }) {
+    expect(payment.id).toBeString();
+    const { adminToken } = await initAdmin({ organization: organization });
+
+    const arr = new PatchableArray();
+    arr.addPatch(PaymentGeneral.patch({
+        id: payment.id,
+        status,
+    }));
+
+    const request = Request.patch({
+        path: '/organization/payments',
+        host: organization.getApiHost(),
+        body: arr,
+        headers: {
+            authorization: 'Bearer ' + adminToken.accessToken,
+        },
+    });
+
+    const response = await testServer.test(new PatchPaymentsEndpoint(), request);
+    expect(response.status).toBe(200);
+}
+export async function markPaid({ payment, organization }: { payment: { id: string }; organization: Organization }) {
+    await changePaymentStatus({
+        payment,
+        organization,
+        status: PaymentStatus.Succeeded,
+    });
+}
+
+export async function markNotPaid({ payment, organization }: { payment: { id: string }; organization: Organization }) {
+    await changePaymentStatus({
+        payment,
+        organization,
+        status: PaymentStatus.Created,
+    });
+}

package/tests/actions/patchUserMember.ts

@@ -0,0 +1,27 @@
+import { AutoEncoderPatchType, PatchableArray } from '@simonbackx/simple-encoding';
+import { Request } from '@simonbackx/simple-endpoints';
+import { Organization, Token, User } from '@stamhoofd/models';
+import { MemberWithRegistrationsBlob } from '@stamhoofd/structures';
+import { PatchUserMembersEndpoint } from '../../src/endpoints/global/registration/PatchUserMembersEndpoint';
+import { testServer } from '../helpers/TestServer';
+
+export async function patchUserMember({ patch, organization, user }: { patch: AutoEncoderPatchType<MemberWithRegistrationsBlob>; organization: Organization; user: User }) {
+    expect(patch.id).toBeString();
+
+    const token = await Token.createToken(user);
+
+    const arr = new PatchableArray();
+    arr.addPatch(patch);
+
+    const request = Request.patch({
+        path: '/members',
+        host: organization.getApiHost(),
+        body: arr,
+        headers: {
+            authorization: 'Bearer ' + token.accessToken,
+        },
+    });
+
+    const response = await testServer.test(new PatchUserMembersEndpoint(), request);
+    expect(response.status).toBe(200);
+}

package/tests/assertions/assertBalances.ts

@@ -0,0 +1,49 @@
+import { BalanceItem } from '@stamhoofd/models';
+import { BalanceItemService } from '../../src/services/BalanceItemService';
+
+export async function assertBalances(selector: { user: { id: string | null } } | { member: { id: string | null } }, balances: Partial<BalanceItem>[]) {
+    await BalanceItemService.flushAll();
+
+    // Fetch all user balances
+    const q = BalanceItem.select();
+    if ('user' in selector && selector.user.id) {
+        q.where('userId', selector.user.id);
+    }
+    else if ('member' in selector && selector.member.id) {
+        q.where('memberId', selector.member.id);
+    }
+    else {
+        throw new Error('Selector must contain either user or member with an id');
+    }
+
+    const userBalances = await q.fetch();
+
+    try {
+        expect(userBalances).toIncludeAllMembers(balances.map(b => expect.objectContaining(b)));
+    }
+    catch (e) {
+        // List all the balances that were found and the ones that were missing
+        if (userBalances.length !== balances.length) {
+            console.error('Difference in number of balances found:', userBalances.length, 'expected:', balances.length);
+        }
+
+        for (const expectedBalance of balances) {
+            let found = false;
+            for (const userBalance of userBalances) {
+                try {
+                    expect(userBalance).toEqual(expect.objectContaining(expectedBalance));
+                    found = true;
+                }
+                catch (e) {
+                    // ignore
+                }
+            }
+
+            if (!found) {
+                console.error('Expected balance not found:', expectedBalance);
+            }
+        }
+
+        throw e;
+    }
+}

package/tests/e2e/api-rate-limits.test.ts

@@ -4,7 +4,7 @@ import { Organization, OrganizationFactory, Token, UserFactory } from '@stamhoof
 
 import { PatchMap } from '@simonbackx/simple-encoding';
 import { ApiUser, ApiUserRateLimits, PermissionLevel, Permissions, PermissionsResourceType, ResourcePermissions, UserMeta, UserPermissions } from '@stamhoofd/structures';
-import { SHExpect, TestUtils } from '@stamhoofd/test-utils';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
 import { CreateApiUserEndpoint } from '../../src/endpoints/organization/dashboard/users/CreateApiUserEndpoint';
 import { testServer } from '../helpers/TestServer';
 import { GetUserEndpoint } from '../../src/endpoints/auth/GetUserEndpoint';
@@ -76,7 +76,7 @@ describe('E2E.APIRateLimits', () => {
             }
             else {
                 await expect(promise).rejects.toThrow(
-                    SHExpect.simpleError({
+                    STExpect.simpleError({
                         code: 'rate_limit',
                     }),
                 );
@@ -110,7 +110,7 @@ describe('E2E.APIRateLimits', () => {
             }
             else {
                 await expect(promise).rejects.toThrow(
-                    SHExpect.simpleError({
+                    STExpect.simpleError({
                         code: 'rate_limit',
                     }),
                 );
@@ -144,7 +144,7 @@ describe('E2E.APIRateLimits', () => {
             }
             else {
                 await expect(promise).rejects.toThrow(
-                    SHExpect.simpleError({
+                    STExpect.simpleError({
                         code: 'rate_limit',
                     }),
                 );
@@ -178,7 +178,7 @@ describe('E2E.APIRateLimits', () => {
             }
             else {
                 await expect(promise).rejects.toThrow(
-                    SHExpect.simpleError({
+                    STExpect.simpleError({
                         code: 'rate_limit',
                     }),
                 );