@stamhoofd/backend 2.110.0 → 2.112.0

package/src/services/uitpas/PassholderEndpoints.ts

@@ -0,0 +1,190 @@
+import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-errors';
+import { handleUitpasResponse } from './handleUitpasResponse.js';
+
+export type GetPassResponse = {
+    passholderId?: string;
+    uitpasNumber: string;
+    firstName?: string;
+    points?: number;
+    postalCode?: string;
+    socialTariff: {
+        status: 'ACTIVE' | 'EXPIRED' | 'NONE' | 'UNKNOWN';
+        endDate?: string;
+    };
+    messages?: {
+        level: 'INFO' | 'WARN' | 'ERROR';
+        text: string;
+    }[];
+};
+
+export class PassholderEndpoints {
+    private readonly baseUrl = getBaseUrl();
+
+    constructor(private readonly access_token: string) {}
+
+    /**
+     * https://docs.publiq.be/docs/uitpas/uitpas-api/reference/operations/get-a-pass
+     * @param uitpasNumber
+     */
+    async getPassByUitpasNumber(uitpasNumber: string): Promise<GetPassResponse> {
+        let response: Response;
+
+        try {
+            response = await fetch(`${this.baseUrl}/passes/${uitpasNumber}`, {
+                method: 'GET',
+                headers: this.getHeaders(),
+                signal: AbortSignal.timeout(10000),
+            });
+        }
+        catch (error) {
+            if (isTimeout(error)) {
+                throw new SimpleError({
+                    statusCode: 408,
+                    code: 'uitpas_timeout',
+                    message: `Timeout when retrieving pass by UiTPAS number`,
+                    human: $t(
+                        `We konden UiTPAS niet bereiken om jouw UiTPAS-nummer te valideren. Probeer het later opnieuw.`,
+                    ),
+                });
+            }
+
+            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.`,
+                ),
+            });
+        }
+
+        try {
+            const json = await handleUitpasResponse(response);
+            return jsonToGetPassResponse(json);
+        }
+        catch (e) {
+            if (isSimpleError(e) || isSimpleErrors(e)) {
+                if (e.hasCode('https://api.publiq.be/probs/uitpas/pass-not-found')) {
+                    throw new SimpleError({
+                        code: 'https://api.publiq.be/probs/uitpas/pass-not-found',
+                        message: 'Pass not found',
+                        human: $t('02f758f9-a1b1-428b-9575-69c4963c2419'),
+                        statusCode: 404,
+                    });
+                }
+            }
+            throw e;
+        }
+    }
+
+    private getHeaders(): Headers {
+        const headers = new Headers();
+        headers.append('Authorization', 'Bearer ' + this.access_token);
+        return headers;
+    }
+}
+
+function isTimeout(error: any): boolean {
+    return error['name'] === 'TimeoutError';
+}
+
+function jsonToGetPassResponse(json: unknown): GetPassResponse {
+    assertValidGetPassResponse(json);
+    return {
+        passholderId: json.passholderId,
+        uitpasNumber: json.uitpasNumber,
+        firstName: json.firstName,
+        points: json.points,
+        postalCode: json.postalCode,
+        socialTariff: {
+            status: json.socialTariff.status,
+            endDate: json.socialTariff.endDate,
+        },
+        messages: json.messages?.map((m) => {
+            return {
+                level: m.level,
+                text: m.text,
+            };
+        }),
+    };
+}
+
+function assertValidGetPassResponse(json: unknown): asserts json is GetPassResponse {
+    try {
+        if (typeof json !== 'object') {
+            throw new Error('Not an object');
+        }
+
+        if (json === null) {
+            throw new Error('Null');
+        }
+
+        const stringProperties = ['passholderId', 'uitpasNumber', 'firstName', 'postalCode'];
+
+        stringProperties.forEach((key) => {
+            if (typeof json[key] !== 'string') {
+                throw new Error(`Invalid ${key}`);
+            }
+        });
+
+        const points = json['points'];
+        if (typeof points !== 'number') {
+            throw new Error('Invalid points');
+        }
+
+        const socialTariff = json['socialTariff'];
+        if (typeof socialTariff !== 'object' || socialTariff === null) {
+            throw new Error('Invalid socialTariff');
+        }
+
+        const status = socialTariff['status'];
+        if (!(status === 'ACTIVE' || status === 'EXPIRED' || status === 'NONE')) {
+            throw new Error('Invalid socialTariff status');
+        }
+
+        const endDate = socialTariff['endDate'];
+        if (endDate !== undefined && typeof endDate !== 'string') {
+            throw new Error('Invalid socialTariff endDate');
+        }
+
+        const messages = json['messages'];
+        if (messages !== undefined) {
+            if (!Array.isArray(messages)) {
+                throw new Error('Invalid messages');
+            }
+
+            messages.forEach((message) => {
+                if (typeof message !== 'object' || message === null) {
+                    throw new Error('Invalid message');
+                }
+
+                const level = message['level'];
+                if (!(level === 'INFO' || level === 'WARN' || level === 'ERROR')) {
+                    throw new Error('Invalid message level');
+                }
+
+                const text = message['text'];
+                if (typeof text !== 'string') {
+                    throw new Error('Invalid message text');
+                }
+            });
+        }
+    }
+    catch (error) {
+        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: ${error.message}`,
+            human: $t(`4c6482ff-e6d9-4ea1-b11d-e12d697b4b7b`),
+        });
+    }
+}
+
+function getBaseUrl(): string {
+    const baseUrl = STAMHOOFD.UITPAS_API_URL;
+
+    if (baseUrl === undefined) {
+        throw new Error('Missing environment variable UITPAS_API_URL');
+    }
+
+    return baseUrl;
+}

package/src/services/uitpas/UitpasService.ts

@@ -1,19 +1,20 @@
 import { Model } from '@simonbackx/simple-database';
+import { isSimpleError, SimpleError } from '@simonbackx/simple-errors';
 import { Order, WebshopUitpasNumber } from '@stamhoofd/models';
-import { Cart, OrderStatus, Product, ProductPrice, UitpasClientCredentialsStatus, UitpasOrganizersResponse } from '@stamhoofd/structures';
-import { v4 as uuidv4 } from 'uuid';
-import { UitpasTokenRepository } from '../../helpers/UitpasTokenRepository';
-import { searchUitpasOrganizers } from './searchUitpasOrganizers';
-import { checkPermissionsFor } from './checkPermissionsFor';
-import { checkUitpasNumbers } from './checkUitpasNumbers';
-import { getSocialTariffForEvent } from './getSocialTariffForEvent';
-import { getSocialTariffForUitpasNumbers } from './getSocialTariffForUitpasNumbers';
-import { searchUitpasEvents } from './searchUitpasEvents';
-import { RegisterTicketSaleRequest, RegisterTicketSaleResponse, registerTicketSales } from './registerTicketSales';
-import { cancelTicketSales } from './cancelTicketSales';
-import { SimpleError } from '@simonbackx/simple-errors';
 import { QueueHandler } from '@stamhoofd/queues';
+import { Cart, OrderStatus, Product, ProductPrice, UitpasClientCredentialsStatus, UitpasOrganizersResponse } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
+import { v4 as uuidv4 } from 'uuid';
+import { UitpasTokenRepository } from '../../helpers/UitpasTokenRepository.js';
+import { cancelTicketSales } from './cancelTicketSales.js';
+import { checkPermissionsFor } from './checkPermissionsFor.js';
+import { checkUitpasNumbers } from './checkUitpasNumbers.js';
+import { getSocialTariffForEvent } from './getSocialTariffForEvent.js';
+import { getSocialTariffForUitpasNumbers } from './getSocialTariffForUitpasNumbers.js';
+import { GetPassResponse, PassholderEndpoints } from './PassholderEndpoints.js';
+import { RegisterTicketSaleRequest, RegisterTicketSaleResponse, registerTicketSales } from './registerTicketSales.js';
+import { searchUitpasEvents } from './searchUitpasEvents.js';
+import { searchUitpasOrganizers } from './searchUitpasOrganizers.js';
 
 type UitpasTicketSale = {
     basePrice: number;
@@ -342,6 +343,30 @@ export class UitpasService {
         return await checkUitpasNumbers(access_token, uitpasNumbers);
     }
 
+    /**
+     * @returns the passholder endpoints
+     */
+    static async getPassByUitpasNumber(uitpasNumber: string): Promise<GetPassResponse> {
+        let access_token!: string;
+        try {
+            access_token = await UitpasTokenRepository.getAccessTokenFor(); // use platform credentials
+        }
+        catch (e) {
+            if (isSimpleError(e) && e.hasCode('uitpas_api_not_configured_for_platform')) {
+                console.error('UiTPAS API has not been configured for this platform, so defaulting to an unknown status for number ', uitpasNumber);
+                // Ignore and return status of unknown
+                return {
+                    uitpasNumber,
+                    socialTariff: {
+                        status: 'UNKNOWN',
+                    },
+                };
+            }
+            throw e;
+        }
+        return new PassholderEndpoints(access_token).getPassByUitpasNumber(uitpasNumber);
+    }
+
     /**
      * Store the uitpas client credentials if they are valid
      * @param organizationId null for platform

package/src/services/uitpas/checkUitpasNumbers.ts

@@ -1,62 +1,11 @@
 import { isSimpleError, isSimpleErrors, SimpleError, SimpleErrors } from '@simonbackx/simple-errors';
 import { DataValidator } from '@stamhoofd/utility';
+import { PassholderEndpoints } from './PassholderEndpoints.js';
 
-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(`4c6482ff-e6d9-4ea1-b11d-e12d697b4b7b`),
-        });
-    }
-}
-
-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')
-        );
-}
-
-async function checkUitpasNumber(access_token: string, uitpasNumber: string) {
-    // static check (using regex)
+export function throwIfInvalidUitpasNumber(uitpasNumber: string) {
     if (!DataValidator.isUitpasNumberValid(uitpasNumber)) {
         throw new SimpleError({
+            statusCode: 400,
             code: 'invalid_uitpas_number',
             message: `Invalid UiTPAS number: ${uitpasNumber}`,
             human: $t(
@@ -64,91 +13,6 @@ async function checkUitpasNumber(access_token: string, uitpasNumber: string) {
             ),
         });
     }
-
-    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(`4c6482ff-e6d9-4ea1-b11d-e12d697b4b7b`),
-        });
-    }
-
-    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
 }
 
 /**
@@ -158,11 +22,23 @@ async function checkUitpasNumber(access_token: string, uitpasNumber: string) {
  * @param uitpasNumbers The uitpas numbers to check
  */
 export async function checkUitpasNumbers(access_token: string, uitpasNumbers: string[]) {
+    const passholderEndpoints = new PassholderEndpoints(access_token);
+
     const simpleErrors = new SimpleErrors();
     for (let i = 0; i < uitpasNumbers.length; i++) {
         const uitpasNumber = uitpasNumbers[i];
         try {
-            await checkUitpasNumber(access_token, uitpasNumber); // Throws if invalid
+            throwIfInvalidUitpasNumber(uitpasNumber);
+            const result = await passholderEndpoints.getPassByUitpasNumber(uitpasNumber);
+            if (result.socialTariff.status !== 'ACTIVE') {
+                new SimpleError({
+                    code: 'non_active_social_tariff',
+                    message: `UiTPAS social tariff is not ACTIVE but ${result.socialTariff.status}`,
+                    human: $t(
+                        `Het opgegeven UiTPAS-nummer heeft geen actief kansentarief. Neem contact op met de UiTPAS-organisatie voor meer informatie.`,
+                    ),
+                });
+            }
         }
         catch (e) {
             if (isSimpleError(e) || isSimpleErrors(e)) {

package/src/services/uitpas/handleUitpasResponse.ts

@@ -0,0 +1,89 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+
+type UitpasErrorResponse = {
+    type: string;
+    title: string;
+    endUserMessage?: {
+        nl: string;
+    };
+};
+
+/**
+ * Throws a SimpleError if the response is not ok
+ * @param response
+ * @returns json
+ */
+export async function handleUitpasResponse(response: Response) {
+    if (response.ok) {
+        const json = await response.json();
+        return json;
+    }
+
+    const error = await uitpasErrorToSimpleError(response);
+    throw error;
+}
+
+async function uitpasErrorToSimpleError(response: Response) {
+    const json: unknown = await response.json().catch(() => { /* ignore */ });
+    console.error('[UITPAS ERROR]', json);
+
+    const statusCode = response.status;
+    let human: string | undefined;
+    let message: string | undefined;
+    let code: string | undefined;
+
+    if (json) {
+        const uitpasError = jsonToUitpasErrorResponse(json);
+        if (uitpasError.endUserMessage) {
+            human = uitpasError.endUserMessage.nl;
+        }
+        message = uitpasError.title;
+        code = uitpasError.type;
+    }
+
+    return new SimpleError({
+        statusCode,
+        code: code ?? 'get-uitpas-error',
+        message: message ?? `Error when retrieving pass by UiTPAS number`,
+        human: human ?? $t('2fcd8eb2-603e-44bb-8b8d-faa131936888'),
+    });
+}
+
+function jsonToUitpasErrorResponse(json: unknown): UitpasErrorResponse {
+    assertValidUitpasError(json);
+    return {
+        type: json.type,
+        title: json.title,
+        endUserMessage: json.endUserMessage
+            ? {
+                    nl: json.endUserMessage.nl,
+                }
+            : undefined,
+    };
+}
+
+function assertValidUitpasError(json: unknown): asserts json is UitpasErrorResponse {
+    if (json === null || typeof json !== 'object') {
+        throw new Error('Not an object');
+    }
+
+    const stringProperties = ['title', 'type'];
+
+    stringProperties.forEach((key) => {
+        if (typeof json[key] !== 'string') {
+            throw new Error(`Invalid ${key}`);
+        }
+    });
+
+    const endUserMessage = json['endUserMessage'];
+    if (endUserMessage !== undefined) {
+        if (typeof endUserMessage !== 'object' || endUserMessage === null) {
+            throw new Error('Invalid endUserMessage');
+        }
+
+        const nl = endUserMessage['nl'];
+        if (typeof nl !== 'string') {
+            throw new Error('Invalid endUserMessage nl');
+        }
+    }
+}

package/src/sql-filters/invoiced-balance-items.ts

@@ -0,0 +1,20 @@
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLFilterDefinitions, SQLValueType } from '@stamhoofd/sql';
+
+export const invoicedBalanceItemCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    name: createColumnFilter({
+        expression: SQL.column('name'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    description: createColumnFilter({
+        expression: SQL.column('description'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+};

package/src/sql-filters/invoices.ts

@@ -0,0 +1,122 @@
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, SQLValueType } from '@stamhoofd/sql';
+import { invoicedBalanceItemCompilers } from './invoiced-balance-items.js';
+
+/**
+ * Defines how to filter payments in the database from StamhoofdFilter objects
+ */
+export const invoiceFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column('id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    number: createColumnFilter({
+        expression: SQL.column('number'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+
+    organizationId: createColumnFilter({
+        expression: SQL.column('organizationId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
+
+    totalWithVAT: createColumnFilter({
+        expression: SQL.column('totalWithVAT'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+
+    totalWithoutVAT: createColumnFilter({
+        expression: SQL.column('totalWithoutVAT'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+
+    VATTotalAmount: createColumnFilter({
+        expression: SQL.column('VATTotalAmount'),
+        type: SQLValueType.Number,
+        nullable: false,
+    }),
+
+    createdAt: createColumnFilter({
+        expression: SQL.column('createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    updatedAt: createColumnFilter({
+        expression: SQL.column('updatedAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    invoicedAt: createColumnFilter({
+        expression: SQL.column('invoicedAt'),
+        type: SQLValueType.Datetime,
+        nullable: true,
+    }),
+    customer: {
+        ...baseSQLFilterCompilers,
+        email: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.email'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        firstName: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.firstName'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        lastName: createColumnFilter({
+            expression: SQL.jsonExtract(SQL.column('customer'), '$.value.lastName'),
+            type: SQLValueType.JSONString,
+            nullable: true,
+        }),
+        name: createColumnFilter({
+            expression: new SQLCast(
+                new SQLConcat(
+                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column('customer'), '$.value.firstName')),
+                    new SQLScalar(' '),
+                    new SQLJsonUnquote(SQL.jsonExtract(SQL.column('customer'), '$.value.lastName')),
+                ),
+                'CHAR',
+            ),
+            type: SQLValueType.String,
+            nullable: true,
+        }),
+        company: {
+            ...baseSQLFilterCompilers,
+            name: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.name'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            VATNumber: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.VATNumber'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            companyNumber: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.companyNumber'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+            administrationEmail: createColumnFilter({
+                expression: SQL.jsonExtract(SQL.column('customer'), '$.value.company.administrationEmail'),
+                type: SQLValueType.JSONString,
+                nullable: true,
+            }),
+        },
+    },
+    items: createExistsFilter(
+        SQL.select()
+            .from(
+                SQL.table('invoiced_balance_items'),
+            ).where(
+                SQL.column('invoiceId'),
+                SQL.parentColumn('id'),
+            ),
+        invoicedBalanceItemCompilers,
+    ),
+};