@stamhoofd/backend 2.89.2 → 2.90.0

package/src/sql-filters/receivable-balances.ts

@@ -1,4 +1,4 @@
-import { SQL, SQLConcat, SQLFilterDefinitions, SQLScalar, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLRelationFilterCompiler } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLConcat, SQLFilterDefinitions, SQLValueType, SQLScalar } from '@stamhoofd/sql';
 import { memberFilterCompilers } from './members';
 import { organizationFilterCompilers } from './organizations';
 import { EmailRelationFilterCompilers } from './shared/EmailRelationFilterCompilers';
@@ -8,23 +8,56 @@ import { EmailRelationFilterCompilers } from './shared/EmailRelationFilterCompil
  */
 export const receivableBalanceFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    objectType: createSQLColumnFilterCompiler('objectType'),
-    amountOpen: createSQLColumnFilterCompiler('amountOpen'),
-    amountPending: createSQLColumnFilterCompiler('amountPending'),
-    nextDueAt: createSQLColumnFilterCompiler('nextDueAt'),
-    lastReminderEmail: createSQLColumnFilterCompiler('lastReminderEmail'),
-    reminderEmailCount: createSQLColumnFilterCompiler('reminderEmailCount'),
-    reminderAmountIncreased: createSQLExpressionFilterCompiler(
-        SQL.if(
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    objectType: createColumnFilter({
+        expression: SQL.column('objectType'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    amountOpen: createColumnFilter({
+        expression: SQL.column('amountOpen'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    amountPending: createColumnFilter({
+        expression: SQL.column('amountPending'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    nextDueAt: createColumnFilter({
+        expression: SQL.column('nextDueAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    lastReminderEmail: createColumnFilter({
+        expression: SQL.column('lastReminderEmail'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    reminderEmailCount: createColumnFilter({
+        expression: SQL.column('reminderEmailCount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    reminderAmountIncreased: createColumnFilter({
+        expression: SQL.if(
             SQL.column('amountOpen'),
             '>',
             SQL.column('lastReminderAmountOpen'),
         ).then(1).else(0),
-        { isJSONValue: false, isJSONObject: false },
-    ),
-    organizations: createSQLRelationFilterCompiler(
+        type: SQLValueType.Boolean,
+        nullable: false,
+    }),
+    organizations: createExistsFilter(
         SQL.select()
             .from(SQL.table('organizations'))
             .where(
@@ -36,9 +69,10 @@ export const receivableBalanceFilterCompilers: SQLFilterDefinitions = {
             ).where(
                 SQL.column('cached_outstanding_balances', 'objectType'),
                 'organization'),
+
         organizationFilterCompilers,
     ),
-    members: createSQLRelationFilterCompiler(
+    members: createExistsFilter(
         SQL.select()
             .from(SQL.table('members'))
             .where(
@@ -52,7 +86,7 @@ export const receivableBalanceFilterCompilers: SQLFilterDefinitions = {
                 'member'),
         memberFilterCompilers,
     ),
-    users: createSQLRelationFilterCompiler(
+    users: createExistsFilter(
         SQL.select()
             .from(SQL.table('users'))
             .where(
@@ -65,13 +99,16 @@ export const receivableBalanceFilterCompilers: SQLFilterDefinitions = {
                 SQL.column('cached_outstanding_balances', 'objectType'),
                 'user'),
         {
-            name: createSQLExpressionFilterCompiler(
-                new SQLConcat(
+            ...baseSQLFilterCompilers,
+            name: createColumnFilter({
+                expression: new SQLConcat(
                     SQL.column('firstName'),
                     new SQLScalar(' '),
                     SQL.column('lastName'),
                 ),
-            ),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
         },
     ),
 

package/src/sql-filters/registration-periods.ts

@@ -1,8 +1,20 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 
 export const registrationPeriodFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    startDate: createSQLColumnFilterCompiler('startDate'),
-    endDate: createSQLColumnFilterCompiler('endDate'),
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    startDate: createColumnFilter({
+        expression: SQL.column('startDate'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    endDate: createColumnFilter({
+        expression: SQL.column('endDate'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
 };

package/src/sql-filters/registrations.ts

@@ -1,5 +1,5 @@
 import { Member, Registration } from '@stamhoofd/models';
-import { baseSQLFilterCompilers, createSQLJoinedRelationFilterCompiler, SQL, SQLFilterDefinitions } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createJoinedRelationFilter, SQL, SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseRegistrationFilterCompilers } from './base-registration-filter-compilers';
 import { memberFilterCompilers } from './members';
 
@@ -8,7 +8,7 @@ export const memberJoin = SQL.join(Member.table).where(SQL.column(Member.table,
 export const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
     ...baseRegistrationFilterCompilers,
-    member: createSQLJoinedRelationFilterCompiler(
+    member: createJoinedRelationFilter(
         memberJoin,
         memberFilterCompilers,
     ),

package/src/sql-filters/shared/EmailRelationFilterCompilers.ts

@@ -1,19 +1,25 @@
-import { createSQLRelationFilterCompiler, SQL, SQLParentNamespace, baseSQLFilterCompilers, createSQLColumnFilterCompiler } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 
 export const EmailRelationFilterCompilers = {
-    emails: createSQLRelationFilterCompiler(
+    emails: createExistsFilter(
         SQL.select()
-            .from(
-                SQL.table('email_recipients'),
-            )
+            .from(SQL.table('email_recipients'))
             .where(
-                SQL.column(SQLParentNamespace, 'id'),
                 SQL.column('objectId'),
+                SQL.column('id'), // Parent table id
             ),
         {
             ...baseSQLFilterCompilers,
-            emailType: createSQLColumnFilterCompiler('emailType'),
-            sentAt: createSQLColumnFilterCompiler('sentAt'),
+            emailType: createColumnFilter({
+                expression: SQL.column('emailType'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            sentAt: createColumnFilter({
+                expression: SQL.column('sentAt'),
+                type: SQLValueType.Datetime,
+                nullable: true,
+            }),
         },
     ),
 };

package/src/sql-filters/tickets.ts

@@ -1,10 +1,30 @@
-import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQLFilterDefinitions } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 
 export const ticketFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    updatedAt: createSQLColumnFilterCompiler('updatedAt'),
-    webshopId: createSQLColumnFilterCompiler('webshopId'),
-    id: createSQLColumnFilterCompiler('id'),
-    createdAt: createSQLColumnFilterCompiler('createdAt'),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    updatedAt: createColumnFilter({
+        expression: SQL.column('updatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    webshopId: createColumnFilter({
+        expression: SQL.column('webshopId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
 };

package/tests/e2e/charge-members.test.ts

@@ -75,6 +75,7 @@ describe('E2E.ChargeMembers', () => {
     });
 
     beforeAll(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
         period = await new RegistrationPeriodFactory({
             startDate: new Date(2023, 0, 1),
             endDate: new Date(2023, 11, 31),

package/src/helpers/UitpasNumberValidator.test.ts

@@ -1,23 +0,0 @@
-import { STExpect } from '@stamhoofd/test-utils';
-import { UitpasNumberValidator } from './UitpasNumberValidator';
-
-describe.skip('UitpasNumberValidator', () => {
-    it('should validate a correct Uitpas number with kansentarief', async () => {
-        const validNumber = '0900000067513';
-        await expect(UitpasNumberValidator.checkUitpasNumber(validNumber)).resolves.toBeUndefined();
-    });
-
-    it('should throw an error for an invalid Uitpas number', async () => {
-        const invalidNumber = '1234567890123';
-        await expect(UitpasNumberValidator.checkUitpasNumber(invalidNumber)).rejects.toThrow(
-            STExpect.simpleError({ code: 'unsuccessful_but_expected_response_retrieving_pass_by_uitpas_number' }),
-        );
-    });
-
-    it('should throw an error for a Uitpas number with kansentarief expired', async () => {
-        const expiredNumber = '0900000058918';
-        await expect(UitpasNumberValidator.checkUitpasNumber(expiredNumber)).rejects.toThrow(
-            STExpect.simpleError({ code: 'uitpas_number_issue' }),
-        );
-    });
-});

package/src/helpers/UitpasNumberValidator.ts

@@ -1,185 +0,0 @@
-import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
-import { UitpasTokenRepository } from './UitpasTokenRepository';
-import { DataValidator } from '@stamhoofd/utility';
-
-type UitpasNumberSuccessfulResponse = {
-    socialTariff: {
-        status: 'ACTIVE' | 'EXPIRED' | 'NONE';
-    };
-    messages?: Array<{
-        text: string;
-    }>;
-};
-
-type UitpasNumberErrorResponse = {
-    title: string; // e.g., "Invalid uitpas number"
-    endUserMessage?: {
-        nl: string;
-    };
-};
-
-function assertIsUitpasNumberSuccessfulResponse(
-    json: unknown,
-): asserts json is UitpasNumberSuccessfulResponse {
-    if (
-        typeof json !== 'object'
-        || json === null
-        || !('socialTariff' in json)
-        || typeof json.socialTariff !== 'object'
-        || json.socialTariff === null
-        || !('status' in json.socialTariff)
-        || typeof json.socialTariff.status !== 'string'
-        || (json.socialTariff.status !== 'ACTIVE' && json.socialTariff.status !== 'EXPIRED' && json.socialTariff.status !== 'NONE')
-        || ('messages' in json && (!Array.isArray(json.messages) || !json.messages.every(
-            (message: unknown) => typeof message === 'object' && message !== null && 'text' in message && typeof message.text === 'string')))
-    ) {
-        console.error('Invalid response when retrieving pass by UiTPAS number:', json);
-        throw new SimpleError({
-            code: 'invalid_response_retrieving_pass_by_uitpas_number',
-            message: `Invalid response when retrieving pass by UiTPAS  number`,
-            human: $t(`Er is een fout opgetreden bij het ophalen van je UiTPAS. Kijk je het nummer even na?`),
-        });
-    }
-}
-
-function isUitpasNumberErrorResponse(
-    json: unknown,
-): json is UitpasNumberErrorResponse {
-    return typeof json === 'object'
-        && json !== null
-        && 'title' in json
-        && typeof json.title === 'string'
-        && (!('endUserMessage' in json)
-            || (typeof json.endUserMessage === 'object' && json.endUserMessage !== null && 'nl' in json.endUserMessage && typeof json.endUserMessage.nl === 'string')
-        );
-}
-
-export class UitpasNumberValidatorStatic {
-    async checkUitpasNumber(uitpasNumber: string) {
-        // static check (using regex)
-        if (!DataValidator.isUitpasNumberValid(uitpasNumber)) {
-            throw new SimpleError({
-                code: 'invalid_uitpas_number',
-                message: `Invalid UiTPAS number: ${uitpasNumber}`,
-                human: $t(
-                    `Het opgegeven UiTPAS-nummer is ongeldig. Controleer het nummer en probeer het opnieuw.`,
-                ),
-            });
-        }
-        const access_token = await UitpasTokenRepository.getAccessTokenFor(); // for nothing, means for platform
-        const baseUrl = 'https://api-test.uitpas.be'; // TO DO: Use the URL from environment variables
-
-        const url = `${baseUrl}/passes/${uitpasNumber}`;
-        const myHeaders = new Headers();
-        myHeaders.append('Authorization', 'Bearer ' + access_token);
-        const requestOptions = {
-            method: 'GET',
-            headers: myHeaders,
-        };
-
-        const response = await fetch(url, requestOptions).catch(() => {
-            // Handle network errors
-            throw new SimpleError({
-                code: 'uitpas_unreachable_retrieving_pass_by_uitpas_number',
-                message: `Network issue when retrieving pass by UiTPAS number`,
-                human: $t(
-                    `We konden UiTPAS niet bereiken om jouw UiTPAS-nummer te valideren. Probeer het later opnieuw.`,
-                ),
-            });
-        });
-        if (!response.ok) {
-            const json: unknown = await response.json().catch(() => { /* ignore */ });
-            let endUserMessage = '';
-
-            if (json) {
-                console.error(`UiTPAS API returned an error for UiTPAS number ${uitpasNumber}:`, json);
-            }
-            else {
-                console.error(`UiTPAS API returned an error for UiTPAS number ${uitpasNumber}:`, response.statusText);
-            }
-
-            if (isUitpasNumberErrorResponse(json)) {
-                endUserMessage = json.endUserMessage ? json.endUserMessage.nl : '';
-            }
-
-            if (endUserMessage) {
-                throw new SimpleError({
-                    code: 'unsuccessful_but_expected_response_retrieving_pass_by_uitpas_number',
-                    message: `Unsuccesful response with message when retrieving pass by UiTPAS number, message: ${endUserMessage}`,
-                    human: endUserMessage,
-                });
-            }
-
-            throw new SimpleError({
-                code: 'unsuccessful_and_unexpected_response_retrieving_pass_by_uitpas_number',
-                message: `Unsuccesful response without message when retrieving pass by UiTPAS number`,
-                human: $t(`Er is een fout opgetreden bij het ophalen van je UiTPAS. Kijk je het nummer even na?`),
-            });
-        }
-
-        const json = await response.json().catch(() => {
-            // Handle JSON parsing errors
-            throw new SimpleError({
-                code: 'invalid_json_retrieving_pass_by_uitpas_number',
-                message: `Invalid json when retrieving pass by UiTPAS  number`,
-                human: $t(
-                    `Er is een fout opgetreden bij het communiceren met UiTPAS. Probeer het later opnieuw.`,
-                ),
-            });
-        });
-        assertIsUitpasNumberSuccessfulResponse(json);
-        if (json.messages) {
-            const humanMessage = json.messages[0].text; // only display the first message
-
-            // alternatively, join all messages
-            // const text = json.messages.map((message: any) => message.text).join(', ');
-
-            throw new SimpleError({
-                code: 'uitpas_number_issue',
-                message: `UiTPAS API returned an error: ${humanMessage}`,
-                human: humanMessage,
-            });
-        }
-        if (json.socialTariff.status !== 'ACTIVE') {
-            // THIS SHOULD NOT HAPPEN, as in that case json.messages should be present
-            throw new SimpleError({
-                code: 'non_active_social_tariff',
-                message: `UiTPAS social tariff is not ACTIVE but ${json.socialTariff.status}`,
-                human: $t(
-                    `Het opgegeven UiTPAS-nummer heeft geen actief kansentarief. Neem contact op met de UiTPAS-organisatie voor meer informatie.`,
-                ),
-            });
-        }
-        // no errors -> the uitpas number is valid and social tariff is applicable
-    }
-
-    /**
-     * Checks multiple uitpas numbers
-     * If any of the uitpas numbers is invalid, it will throw a SimpleErrors instance with all errors.
-     * The field of the error will be the index of the uitpas number in the array.
-     * @param uitpasNumbers The uitpas numbers to check
-     */
-    async checkUitpasNumbers(uitpasNumbers: string[]) {
-        const simpleErrors = new SimpleErrors();
-        for (let i = 0; i < uitpasNumbers.length; i++) {
-            const uitpasNumber = uitpasNumbers[i];
-            try {
-                await this.checkUitpasNumber(uitpasNumber); // Throws if invalid
-            }
-            catch (e) {
-                if (isSimpleError(e) || isSimpleErrors(e)) {
-                    e.addNamespace(i.toString());
-                    simpleErrors.addError(e);
-                }
-                else {
-                    throw e;
-                }
-            }
-        }
-        if (simpleErrors.errors.length > 0) {
-            throw simpleErrors;
-        }
-    }
-}
-
-export const UitpasNumberValidator = new UitpasNumberValidatorStatic();