@stamhoofd/backend 2.110.0 → 2.112.0

package/src/sql-filters/payments.ts

@@ -1,5 +1,5 @@
 import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
-import { balanceItemPaymentsCompilers } from './balance-item-payments';
+import { balanceItemPaymentsCompilers } from './balance-item-payments.js';
 
 /**
  * Defines how to filter payments in the database from StamhoofdFilter objects
@@ -16,6 +16,11 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: false,
     }),
+    type: createColumnFilter({
+        expression: SQL.column('type'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
     status: createColumnFilter({
         expression: SQL.column('status'),
         type: SQLValueType.String,
@@ -56,6 +61,11 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    hasInvoice: createColumnFilter({
+        expression: SQL.isNull(SQL.column('invoiceId')),
+        type: SQLValueType.Boolean,
+        nullable: false,
+    }),
     customer: {
         ...baseSQLFilterCompilers,
         email: createColumnFilter({

package/src/sql-sorters/invoices.ts

@@ -0,0 +1,83 @@
+import { Invoice } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
+
+export const invoiceSorters: SQLSortDefinitions<Invoice> = {
+    // 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,
+            });
+        },
+    },
+    invoicedAt: {
+        getValue(a) {
+            return a.invoicedAt !== null ? Formatter.dateTimeIso(a.invoicedAt, 'UTC') : null;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('invoicedAt'),
+                direction,
+            });
+        },
+    },
+    createdAt: {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.createdAt, 'UTC');
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
+
+    totalWithVAT: {
+        getValue(a) {
+            return a.totalWithVAT;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('totalWithVAT'),
+                direction,
+            });
+        },
+    },
+
+    totalWithoutVAT: {
+        getValue(a) {
+            return a.totalWithoutVAT;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('totalWithoutVAT'),
+                direction,
+            });
+        },
+    },
+
+    VATTotalAmount: {
+        getValue(a) {
+            return a.VATTotalAmount;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('VATTotalAmount'),
+                direction,
+            });
+        },
+    },
+};

package/src/sql-sorters/payments.ts

@@ -55,4 +55,37 @@ export const paymentSorters: SQLSortDefinitions<Payment> = {
             });
         },
     },
+    hasInvoice: {
+        getValue(a) {
+            return a.invoiceId ? 1 : 0;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.isNull(SQL.column('invoiceId')),
+                direction,
+            });
+        },
+    },
+    method: {
+        getValue(a) {
+            return a.method;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('method'),
+                direction,
+            });
+        },
+    },
+    type: {
+        getValue(a) {
+            return a.type;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('type'),
+                direction,
+            });
+        },
+    },
 };

package/tests/e2e/bundle-discounts.test.ts

@@ -2,14 +2,14 @@ import { Request } from '@simonbackx/simple-endpoints';
 import { BalanceItem, BalanceItemFactory, GroupFactory, MemberFactory, Organization, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriod, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
 import { AccessRight, AppliedRegistrationDiscount, BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, BooleanStatus, GroupPriceDiscount, GroupPriceDiscountType, IDRegisterCart, IDRegisterCheckout, IDRegisterItem, PaymentMethod, PermissionLevel, Permissions, PermissionsResourceType, ReduceablePrice, ResourcePermissions } from '@stamhoofd/structures';
 import { STExpect, TestUtils } from '@stamhoofd/test-utils';
-import { RegisterMembersEndpoint } from '../../src/endpoints/global/registration/RegisterMembersEndpoint';
-import { assertBalances } from '../assertions/assertBalances';
-import { testServer } from '../helpers/TestServer';
-import { initBundleDiscount } from '../init/initBundleDiscount';
-import { initStripe } from '../init/initStripe';
-import { initAdmin } from '../init/initAdmin';
-import { BalanceItemService } from '../../src/services/BalanceItemService';
-import { initPermissionRole } from '../init';
+import { RegisterMembersEndpoint } from '../../src/endpoints/global/registration/RegisterMembersEndpoint.js';
+import { BalanceItemService } from '../../src/services/BalanceItemService.js';
+import { assertBalances } from '../assertions/assertBalances.js';
+import { testServer } from '../helpers/TestServer.js';
+import { initAdmin } from '../init/initAdmin.js';
+import { initBundleDiscount } from '../init/initBundleDiscount.js';
+import { initPermissionRole } from '../init/initPermissionRole.js';
+import { initStripe } from '../init/initStripe.js';
 
 const baseUrl = `/members/register`;
 

package/tests/e2e/tests-disable-net-connect.test.ts

@@ -0,0 +1,5 @@
+test('Should disallow net connect if request is not mocked', async () => {
+    const promise = fetch('https://www.google.com');
+
+    await expect(promise).rejects.toThrow(/Disallowed net connect/);
+});

package/tests/helpers/StripeMocker.ts

@@ -4,9 +4,10 @@ import nock from 'nock';
 import qs from 'qs';
 import { v4 as uuidv4 } from 'uuid';
 
-import { StripeWebookEndpoint } from '../../src/endpoints/global/payments/StripeWebhookEndpoint';
-import { StripeHelper } from '../../src/helpers/StripeHelper';
-import { testServer } from './TestServer';
+import { StripeWebookEndpoint } from '../../src/endpoints/global/payments/StripeWebhookEndpoint.js';
+import { StripeHelper } from '../../src/helpers/StripeHelper.js';
+import { testServer } from './TestServer.js';
+import { resetNock } from './resetNock.js';
 
 export class StripeMocker {
     paymentIntents: { id: string }[] = [];
@@ -215,8 +216,7 @@ export class StripeMocker {
     }
 
     stop() {
-        nock.cleanAll();
-        nock.disableNetConnect();
+        resetNock();
     }
 }
 

package/tests/helpers/UitpasApiMocker.ts

@@ -0,0 +1,175 @@
+import { sleep } from '@stamhoofd/utility';
+import nock from 'nock';
+import { resetNock } from './resetNock.js';
+
+export type UitpasSocialTariff = {
+    status: 'ACTIVE' | 'EXPIRED' | 'NONE';
+    endDate?: string;
+};
+
+export type UitpasMessage = {
+    level: 'INFO' | 'WARN' | 'ERROR';
+    text: string;
+};
+
+export type UitpasApiResponse = {
+    passholderId: string;
+    uitpasNumber: string;
+    firstName: string;
+    points: number;
+    postalCode: string;
+    socialTariff: UitpasSocialTariff;
+    messages?: UitpasMessage[];
+};
+
+export class UitpasMocker {
+    /**
+     * Real test data from uitpas api
+     * https://docs.publiq.be/docs/uitpas/test-dataset
+     */
+    static readonly testData = new Map<string, UitpasApiResponse>([
+        [
+            '0900000095902',
+            {
+                passholderId: '6eb040fd-3c60-4049-8170-c61e4e52c009',
+                uitpasNumber: '0900000095902',
+                firstName: 'Valère',
+                points: 8150,
+                postalCode: '9000',
+                socialTariff: { status: 'NONE' },
+            },
+        ],
+        [
+            /**
+             * Example of an uitpas that does not end with 1X but is active
+             */
+            '0900011354829',
+            {
+                passholderId: '6eb040fd-3c60-4049-8170-c61e4e52c009',
+                uitpasNumber: '0900000095902',
+                firstName: 'Valère',
+                points: 8150,
+                postalCode: '9000',
+                socialTariff: {
+                    status: 'ACTIVE',
+                    endDate: '2026-04-30T21:59:59+00:00',
+                },
+            },
+        ],
+        [
+            '0900011354819',
+            {
+                passholderId: 'f24d31b4-ffab-4ded-98b6-3ab4a6308d4d',
+                uitpasNumber: '0900011354819',
+                firstName: 'Bernadette',
+                points: 400,
+                postalCode: '9340',
+                socialTariff: {
+                    status: 'ACTIVE',
+                    endDate: '2026-04-30T21:59:59+00:00',
+                },
+            },
+        ],
+        [
+            '0900000031618',
+            {
+                passholderId: 'd146126c-cc42-4b7f-8431-bb71a04131aa',
+                uitpasNumber: '0900000031618',
+                firstName: 'Vervallen Pas',
+                points: 4,
+                postalCode: '9000',
+                socialTariff: {
+                    status: 'EXPIRED',
+                    endDate: '2025-01-28T22:59:59+00:00',
+                },
+                messages: [
+                    {
+                        level: 'WARN',
+                        text: 'Je sociaal tarief is verlopen. Contacteer je UiTPAS balie',
+                    },
+                ],
+            },
+        ],
+    ]);
+
+    #forceFailure = false;
+    #requestTimeoutInMs = 0;
+
+    reset() {
+        this.#forceFailure = false;
+        this.#requestTimeoutInMs = 0;
+    }
+
+    forceFailure() {
+        this.#forceFailure = true;
+    }
+
+    setRequestTimeout(ms: number) {
+        this.#requestTimeoutInMs = ms;
+    }
+
+    start() {
+        if (
+            !STAMHOOFD.UITPAS_API_CLIENT_ID
+            || !STAMHOOFD.UITPAS_API_CLIENT_SECRET?.startsWith('sk_test_')
+        ) {
+            throw new Error(
+                'Invalid UITPAS_API_CLIENT_SECRET. Even in test mode it should start with sk_test_',
+            );
+        }
+
+        // mock access-token
+        nock('https://account-test.uitid.be')
+            .persist()
+            .post('/realms/uitid/protocol/openid-connect/token')
+            .reply(200, {
+                access_token: 'fake-access-token',
+                token_type: 'Bearer',
+                expires_in: 86400,
+            });
+
+        // mock get passes
+        nock('https://api-test.uitpas.be')
+            .persist()
+            .get(/\/passes\/(\d+)/)
+            .reply(async (uri: string) => {
+                const matchArray = uri.match(/\/passes\/(\d+)/);
+
+                if (this.#requestTimeoutInMs) {
+                    await sleep(this.#requestTimeoutInMs);
+                }
+
+                if (!matchArray) {
+                    return [500];
+                }
+
+                if (this.#forceFailure) {
+                    return [503];
+                }
+
+                const uitpasNumber = matchArray[1];
+                const result = UitpasMocker.testData.get(uitpasNumber);
+                if (!result) {
+                    return [
+                        404,
+                        {
+                            type: 'https://api.publiq.be/probs/uitpas/pass-not-found',
+                            title: 'Pass not found',
+                            status: 404,
+                            detail: '0900000031617',
+                            endUserMessage: {
+                                nl: 'Het UiTPAS-nummer dat je invulde konden we niet terugvinden. Kijk je het nummer even na?',
+                            },
+                        },
+                    ];
+                }
+
+                return [200, result];
+            });
+    }
+
+    stop() {
+        this.reset();
+        resetNock();
+    }
+}

package/tests/helpers/index.ts

@@ -0,0 +1 @@
+export * from './UitpasApiMocker.js';

package/tests/helpers/resetNock.ts

@@ -0,0 +1,7 @@
+import nock from 'nock';
+import { PayconiqMocker } from './PayconiqMocker.js';
+
+export function resetNock() {
+    nock.cleanAll();
+    PayconiqMocker.setup();
+}

package/tests/init/index.ts

@@ -4,3 +4,4 @@ export * from './initPayconiq';
 export * from './initBundleDiscount';
 export * from './initStripe';
 export * from './initPermissionRole';
+export * from './initUitpasApi';

package/tests/init/initPayconiq.ts

@@ -1,6 +1,6 @@
-import { PaymentMethod } from '@stamhoofd/structures';
-import { PayconiqMocker } from '../helpers/PayconiqMocker';
 import { Organization } from '@stamhoofd/models';
+import { PaymentMethod } from '@stamhoofd/structures';
+import { PayconiqMocker } from '../helpers/PayconiqMocker.js';
 
 export async function initPayconiq({ organization }: { organization: Organization }) {
     organization.meta.registrationPaymentConfiguration.paymentMethods.push(PaymentMethod.Payconiq);

package/tests/init/initStripe.ts

@@ -1,7 +1,7 @@
 import { Organization } from '@stamhoofd/models';
-import { StripeMocker } from '../helpers/StripeMocker';
 import { PaymentMethod } from '@stamhoofd/structures';
 import { TestUtils } from '@stamhoofd/test-utils';
+import { StripeMocker } from '../helpers/StripeMocker.js';
 
 export async function initStripe({ organization }: { organization: Organization }) {
     const stripeMocker = new StripeMocker();

package/tests/init/initUitpasApi.ts

@@ -0,0 +1,14 @@
+import { TestUtils } from '@stamhoofd/test-utils';
+import { UitpasMocker } from '../helpers/UitpasApiMocker.js';
+
+export function initUitpasApi(): UitpasMocker {
+    const mocker = new UitpasMocker();
+
+    mocker.start();
+
+    TestUtils.scheduleAfterThisTest(() => {
+        mocker.stop();
+    });
+
+    return mocker;
+}

package/tests/jest.global.setup.ts

@@ -1,12 +1,14 @@
-import { TestUtils } from '@stamhoofd/test-utils';
+// first import nock
 import nock from 'nock';
+
+// prevent nock import from being removed on save
+console.log('Imported nock: ', !!nock);
+
+import { TestUtils } from '@stamhoofd/test-utils';
 import path from 'path';
 const emailPath = require.resolve('@stamhoofd/email');
 const modelsPath = require.resolve('@stamhoofd/models');
 
-// Disable network requests
-nock.disableNetConnect();
-
 // Set timezone!
 process.env.TZ = 'UTC';
 

package/tests/jest.setup.ts

@@ -1,3 +1,6 @@
+// first import nock
+import nock from 'nock';
+
 import { Column, Database } from '@simonbackx/simple-database';
 import { Request } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
@@ -7,11 +10,11 @@ import { Version } from '@stamhoofd/structures';
 import { TestUtils } from '@stamhoofd/test-utils';
 import { sleep } from '@stamhoofd/utility';
 import * as jose from 'jose';
-import nock from 'nock';
-import { GlobalHelper } from '../src/helpers/GlobalHelper';
-import { BalanceItemService } from '../src/services/BalanceItemService';
-import { PayconiqMocker } from './helpers/PayconiqMocker';
-import './toMatchMap';
+import { GlobalHelper } from '../src/helpers/GlobalHelper.js';
+import { BalanceItemService } from '../src/services/BalanceItemService.js';
+import { PayconiqMocker } from './helpers/PayconiqMocker.js';
+import { resetNock } from './helpers/resetNock.js';
+import './toMatchMap.js';
 
 // Set version of saved structures
 Column.setJSONVersion(Version);
@@ -33,7 +36,7 @@ if (new Date().getTimezoneOffset() !== 0) {
 console.log = jest.fn();
 
 beforeAll(async () => {
-    nock.cleanAll();
+    resetNock();
     nock.disableNetConnect();
 
     await Database.delete('DELETE FROM `tokens`');
@@ -111,4 +114,7 @@ afterEach(async () => {
 
 TestUtils.setup();
 EmailMocker.infect();
+
+// should be mocked first (before node https imports)
+PayconiqMocker.setup();
 PayconiqMocker.infect();