@stamhoofd/backend 2.89.1 → 2.90.0

package/src/services/uitpas/getSocialTariffForUitpasNumbers.ts

@@ -0,0 +1,181 @@
+import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
+
+type SocialTariffReponse = {
+    available: Array<{
+        price: number;
+        remaining: number;
+        // other properties ignored
+    }>;
+    endUserMessage?: {
+        nl: string;
+    };
+};
+
+type SocialTariffErrorResponse = {
+    title: string; // e.g., "Invalid uitpas number"
+    endUserMessage?: {
+        nl: string;
+    };
+};
+
+function assertsIsSocialTariffResponse(json: unknown): asserts json is SocialTariffReponse {
+    if (
+        typeof json !== 'object'
+        || json === null
+        || !('available' in json)
+        || !Array.isArray(json.available)
+        || !json.available.every(
+            (item: unknown) => typeof item === 'object' && item !== null && 'price' in item && typeof item.price === 'number' && 'remaining' in item && typeof item.remaining === 'number',
+        )
+    ) {
+        console.error('Invalid response when getting UiTPAS social tariff:', json);
+        throw new SimpleError({
+            code: 'invalid_response_getting_uitpas_social_tariff',
+            message: `Invalid response when getting UiTPAS social tariff`,
+            human: $t(`Er is een fout opgetreden bij het ophalen van het kansentarief voor jouw UiTPAS-nummer. Probeer het later opnieuw.`),
+        });
+    }
+}
+
+function isSocialTariffErrorResponse(
+    json: unknown,
+): json is SocialTariffErrorResponse {
+    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')
+        );
+}
+
+async function getSocialTariffForUitpasNumber(access_token: string, uitpasNumber: string, basePrice: number, uitpasEventUrl: string) {
+    const baseUrl = 'https://api-test.uitpas.be/tariffs';
+    const params = new URLSearchParams();
+    params.append('regularPrice', (basePrice / 100).toFixed(2));
+    const eventId = uitpasEventUrl.split('/').pop();
+    if (!eventId) {
+        throw new SimpleError({
+            code: 'invalid_uitpas_event_url',
+            message: `Invalid UiTPAS event URL: ${uitpasEventUrl}`,
+            human: $t(`De opgegeven UiTPAS-evenement URL is ongeldig.`),
+        });
+    }
+    params.append('eventId', eventId);
+    params.append('uitpasNumber', uitpasNumber);
+    params.append('type', 'SOCIALTARIFF'); // this ensures we get the social tariff or a message that explains why it's not available
+    const url = `${baseUrl}?${params.toString()}`;
+    const myHeaders = new Headers();
+    myHeaders.append('Authorization', 'Bearer ' + access_token);
+    myHeaders.append('Accept', 'application/json');
+    const requestOptions = {
+        method: 'GET',
+        headers: myHeaders,
+    };
+    const response = await fetch(url, requestOptions).catch(() => {
+        // Handle network errors
+        throw new SimpleError({
+            code: 'uitpas_unreachable_getting_static_uitpas_social_tariff',
+            message: `Network issue when getting static UiTPAS social tariff`,
+            human: $t(
+                `We konden UiTPAS niet bereiken om jouw kansentarief op te zoeken. 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} with event id ${eventId}:`, json);
+        }
+        else {
+            console.error(`UiTPAS API returned an error for UiTPAS number ${uitpasNumber} with event id ${eventId}:`, response.statusText);
+        }
+
+        if (isSocialTariffErrorResponse(json)) {
+            endUserMessage = json.endUserMessage ? json.endUserMessage.nl : '';
+        }
+
+        if (endUserMessage) {
+            throw new SimpleError({
+                code: 'unsuccessful_but_expected_response_retrieving_social_tariff_by_uitpas_number',
+                message: `Unsuccesful response with message when retrieving social tariff by UiTPAS number, message: ${endUserMessage}`,
+                human: endUserMessage,
+            });
+        }
+
+        throw new SimpleError({
+            code: 'unsuccessful_and_unexpected_response_retrieving_social_tariff_by_uitpas_number',
+            message: `Unsuccesful response without message when retrieving social tariff by UiTPAS number`,
+            human: $t(`Er is een fout opgetreden bij het ophalen van je UiTPAS kansentarief. Kijk je het nummer even na?`),
+        });
+    }
+    const json = await response.json().catch(() => {
+        // Handle JSON parsing errors
+        throw new SimpleError({
+            code: 'invalid_json_getting_static_uitpas_social_tariff',
+            message: `Invalid json when getting static UiTPAS social tariff`,
+            human: $t(
+                `Er is een fout opgetreden bij het communiceren met UiTPAS. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+
+    assertsIsSocialTariffResponse(json);
+    if (json.available.length === 0) {
+        if (json.endUserMessage) {
+            throw new SimpleError({
+                code: 'no_social_tariff_available_with_message',
+                message: `No social tariff available for event ${uitpasEventUrl} with message`,
+                human: json.endUserMessage.nl,
+            });
+        }
+        throw new SimpleError({
+            code: 'no_social_tariff_available',
+            message: `No social tariff available for event ${uitpasEventUrl}`,
+            human: $t(`Er is geen kansentarief beschikbaar voor dit evenement.`),
+        });
+    }
+    if (json.available.length > 1) {
+        console.warn('Multiple social tariffs available for event', uitpasEventUrl, '(used ', json.available[0].price, ' as base price. All options:', json.available);
+    }
+    if (json.endUserMessage) {
+        console.warn('UiTPAS API returned an end user message for event', uitpasEventUrl, ':', json.endUserMessage.nl);
+        console.warn('This message was not shown to the user, as a social tariff wass available.');
+    }
+    if (json.available[0].remaining < 1) {
+        throw new SimpleError({
+            code: 'no_remaining_social_tariff',
+            message: `No remaining social tariff for event ${uitpasEventUrl} and UiTPAS number ${uitpasNumber}`,
+            human: $t(`Je hebt recht op UiTPAS-kansentarief maar het overblijvend aantal is niet voldoende.`),
+        });
+    }
+    console.log('Social tariff for UiTPAS number', uitpasNumber, 'with event id', uitpasEventUrl, 'is', json.available[0].price, 'euros');
+    return Math.round((json.available[0].price) * 100);
+}
+
+export async function getSocialTariffForUitpasNumbers(access_token: string, uitpasNumbers: string[], basePrice: number, uitpasEventUrl: string) {
+    const simpleErrors = new SimpleErrors();
+    const reducedPrices = new Array<number>(uitpasNumbers.length);
+    for (let i = 0; i < uitpasNumbers.length; i++) {
+        const uitpasNumber = uitpasNumbers[i];
+        try {
+            reducedPrices[i] = await getSocialTariffForUitpasNumber(access_token, uitpasNumber, basePrice, uitpasEventUrl); // Throws if invalid
+        }
+        catch (e) {
+            if (isSimpleError(e) || isSimpleErrors(e)) {
+                e.addNamespace(i.toString());
+                e.addNamespace('uitpasNumbers');
+                simpleErrors.addError(e);
+            }
+            else {
+                throw e;
+            }
+        }
+    }
+    if (simpleErrors.errors.length > 0) {
+        throw simpleErrors;
+    }
+    return reducedPrices;
+}

package/src/services/uitpas/searchUitpasOrganizers.ts

@@ -0,0 +1,93 @@
+import { UitpasOrganizerResponse, UitpasOrganizersResponse } from '@stamhoofd/structures';
+import { SimpleError } from '@simonbackx/simple-errors';
+
+type OrganizersResponse = {
+    totalItems: number;
+    member: Array<{
+        id: string;
+        name: string;
+    }>;
+};
+
+function assertIsOrganizersResponse(json: unknown): asserts json is OrganizersResponse {
+    if (
+        typeof json !== 'object'
+        || json === null
+        || !('totalItems' in json)
+        || typeof json.totalItems !== 'number'
+        || !('member' in json)
+        || !Array.isArray(json.member)
+        || !json.member.every(
+            (member: unknown) => typeof member === 'object' && member !== null && 'id' in member && typeof member.id === 'string' && 'name' in member && typeof member.name === 'string',
+        )
+    ) {
+        console.error('Invalid response when searching for UiTPAS organizers:', json);
+        throw new SimpleError({
+            code: 'invalid_response_searching_uitpas_organizers',
+            message: `Invalid response when searching for UiTPAS organizers`,
+            human: $t(`Er is een fout opgetreden bij het zoeken naar UiTPAS-organisaties. Probeer het later opnieuw.`),
+        });
+    }
+}
+
+export async function searchUitpasOrganizers(access_token: string, name: string): Promise<UitpasOrganizersResponse> {
+    // uses platform credentials
+    // https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/list-organizers
+    if (name === '') {
+        throw new SimpleError({
+            code: 'empty_uitpas_organizer_name',
+            message: `Empty name when searching for UiTPAS organizers`,
+            human: $t(`Je moet een naam opgeven om UiTPAS-organisaties te zoeken.`),
+        });
+    }
+    const baseUrl = 'https://api-test.uitpas.be/organizers';
+    const params = new URLSearchParams();
+    params.append('name', name);
+    params.append('limit', '200');
+    const url = `${baseUrl}?${params.toString()}`;
+    const myHeaders = new Headers();
+    myHeaders.append('Authorization', 'Bearer ' + access_token);
+    myHeaders.append('Accept', 'application/json');
+    const requestOptions = {
+        method: 'GET',
+        headers: myHeaders,
+    };
+    const response = await fetch(url, requestOptions).catch(() => {
+        // Handle network errors
+        throw new SimpleError({
+            code: 'uitpas_unreachable_searching_organizers',
+            message: `Network issue when searching for UiTPAS organizers`,
+            human: $t(
+                `We konden UiTPAS niet bereiken om UiTPAS-organisaties op te zoeken. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+    if (!response.ok) {
+        throw new SimpleError({
+            code: 'unsuccessful_response_searching_uitpas_organizers',
+            message: `Unsuccessful response when searching for UiTPAS organizers`,
+            human: $t(`Er is een fout opgetreden bij het verbinden met UiTPAS. Probeer het later opnieuw.`),
+        });
+    }
+    const json = await response.json().catch(() => {
+        // Handle JSON parsing errors
+        throw new SimpleError({
+            code: 'invalid_json_searching_uitpas_organizers',
+            message: `Invalid json when searching for UiTPAS organizers`,
+            human: $t(
+                `Er is een fout opgetreden bij het communiceren met UiTPAS. Probeer het later opnieuw.`,
+            ),
+        });
+    });
+
+    assertIsOrganizersResponse(json);
+    const organizersResponse = new UitpasOrganizersResponse();
+    organizersResponse.totalItems = json.totalItems;
+    organizersResponse.member = json.member.map((member) => {
+        const organizer = new UitpasOrganizerResponse();
+        organizer.id = member.id;
+        organizer.name = member.name;
+        return organizer;
+    });
+    return organizersResponse;
+}

package/src/sql-filters/audit-logs.ts

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

package/src/sql-filters/balance-item-payments.ts

@@ -1,13 +1,28 @@
-import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 
 export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'id')),
-    price: createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'price')),
-
-    balanceItem: createSQLFilterNamespace({
-        ...baseSQLFilterCompilers,
-        id: createSQLColumnFilterCompiler(SQL.column('balance_items', 'id')),
-        description: createSQLColumnFilterCompiler(SQL.column('balance_items', 'description')),
+    id: createColumnFilter({
+        expression: SQL.column('balance_item_payments', 'id'),
+        type: SQLValueType.String,
+        nullable: false,
     }),
+    price: createColumnFilter({
+        expression: SQL.column('balance_item_payments', 'price'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    balanceItem: {
+        ...baseSQLFilterCompilers,
+        id: createColumnFilter({
+            expression: SQL.column('balance_items', 'id'),
+            type: SQLValueType.String,
+            nullable: false,
+        }),
+        description: createColumnFilter({
+            expression: SQL.column('balance_items', 'description'),
+            type: SQLValueType.String,
+            nullable: false,
+        }),
+    },
 };

package/src/sql-filters/base-registration-filter-compilers.ts

@@ -1,37 +1,88 @@
-import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLOneToOneRelationFilterCompiler, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 import { organizationFilterCompilers } from './organizations';
 
 export const baseRegistrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
     /**
      * @deprecated
      */
-    price: createSQLColumnFilterCompiler('price', { nullable: true }),
+    price: createColumnFilter({
+        expression: SQL.column('price'),
+        type: SQLValueType.Number,
+        nullable: true,
+    }),
     /**
      * @deprecated
      */
-    pricePaid: createSQLColumnFilterCompiler('pricePaid'),
-    canRegister: createSQLColumnFilterCompiler('canRegister'),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    groupId: createSQLColumnFilterCompiler('groupId'),
-    registeredAt: createSQLColumnFilterCompiler('registeredAt', { nullable: true }),
-    periodId: createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
-    deactivatedAt: createSQLColumnFilterCompiler(SQL.column('registrations', 'deactivatedAt'), { nullable: true }),
-    group: createSQLFilterNamespace({
+    pricePaid: createColumnFilter({
+        expression: SQL.column('pricePaid'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+    canRegister: createColumnFilter({
+        expression: SQL.column('canRegister'),
+        type: SQLValueType.Boolean,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    groupId: createColumnFilter({
+        expression: SQL.column('groupId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    registeredAt: createColumnFilter({
+        expression: SQL.column('registeredAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    periodId: createColumnFilter({
+        expression: SQL.column('registrations', 'periodId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    deactivatedAt: createColumnFilter({
+        expression: SQL.column('registrations', 'deactivatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    group: {
         ...baseSQLFilterCompilers,
-        id: createSQLColumnFilterCompiler('groupId'),
-        name: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        status: createSQLExpressionFilterCompiler(
-            SQL.column('groups', 'status'),
-            { isJSONValue: true, type: SQLValueType.JSONString },
-        ),
-        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), { nullable: true }),
-    }),
-    organization: createSQLOneToOneRelationFilterCompiler(
+        id: createColumnFilter({
+            expression: SQL.column('groupId'),
+            type: SQLValueType.String,
+            nullable: false,
+        }),
+        type: createColumnFilter({
+            expression: SQL.column('groups', 'type'),
+            type: SQLValueType.String,
+            nullable: false,
+        }),
+        name: createColumnFilter({
+            expression: SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name'),
+            type: SQLValueType.JSONString,
+            nullable: false,
+        }),
+        status: createColumnFilter({
+            expression: SQL.column('groups', 'status'),
+            type: SQLValueType.String,
+            nullable: false,
+        }),
+        defaultAgeGroupId: createColumnFilter({
+            expression: SQL.column('groups', 'defaultAgeGroupId'),
+            type: SQLValueType.String,
+            nullable: true,
+        }),
+    },
+    organization: createExistsFilter(
         SQL.select()
             .from(SQL.table('organizations'))
             .where(

package/src/sql-filters/documents.ts

@@ -1,17 +1,50 @@
-import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 
 export const documentFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    description: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('data'), '$.value.description'),
-        { isJSONValue: true, type: SQLValueType.JSONString },
-    ),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    templateId: createSQLColumnFilterCompiler('templateId'),
-    memberId: createSQLColumnFilterCompiler('memberId'),
-    updatedAt: createSQLColumnFilterCompiler('updatedAt'),
-    createdAt: createSQLColumnFilterCompiler('createdAt'),
-    number: createSQLColumnFilterCompiler('number'),
-    status: createSQLColumnFilterCompiler('status'),
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    description: createColumnFilter({
+        expression: SQL.jsonValue(SQL.column('data'), '$.value.description'),
+        type: SQLValueType.JSONString,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    templateId: createColumnFilter({
+        expression: SQL.column('templateId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    memberId: createColumnFilter({
+        expression: SQL.column('memberId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+    updatedAt: createColumnFilter({
+        expression: SQL.column('updatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    number: createColumnFilter({
+        expression: SQL.column('number'),
+        type: SQLValueType.Number,
+        nullable: true,
+    }),
+    status: createColumnFilter({
+        expression: SQL.column('status'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
 };

package/src/sql-filters/event-notifications.ts

@@ -1,4 +1,4 @@
-import { SQL, SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLJoinedRelationFilterCompiler, createSQLRelationFilterCompiler } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createJoinedRelationFilter, createExistsFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
 import { eventFilterCompilers } from './events';
 import { organizationFilterCompilers } from './organizations';
 
@@ -6,20 +6,56 @@ export const organizationJoin = SQL.join('organizations').where(SQL.column('orga
 
 export const eventNotificationsFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    typeId: createSQLColumnFilterCompiler('typeId'),
-    periodId: createSQLColumnFilterCompiler('periodId'),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    startDate: createSQLColumnFilterCompiler('startDate'),
-    endDate: createSQLColumnFilterCompiler('endDate'),
-    submittedAt: createSQLColumnFilterCompiler('submittedAt'),
-    createdAt: createSQLColumnFilterCompiler('createdAt'),
-    status: createSQLColumnFilterCompiler('status'),
-    organization: createSQLJoinedRelationFilterCompiler(
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    typeId: createColumnFilter({
+        expression: SQL.column('typeId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    periodId: createColumnFilter({
+        expression: SQL.column('periodId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        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,
+    }),
+    submittedAt: createColumnFilter({
+        expression: SQL.column('submittedAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    status: createColumnFilter({
+        expression: SQL.column('status'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organization: createJoinedRelationFilter(
         organizationJoin,
         organizationFilterCompilers,
     ),
-    events: createSQLRelationFilterCompiler(
+    events: createExistsFilter(
         SQL.select()
             .from(
                 SQL.table('events'),