@stamhoofd/backend 2.132.1 → 2.134.0

package/src/services/InvoiceXMLService.test.ts

@@ -0,0 +1,161 @@
+import { BalanceItemFactory, Invoice, InvoicedBalanceItem, OrganizationFactory } from '@stamhoofd/models';
+import { Address, Company, File, PaymentCustomer, PeppolEndointId, VATSubtotal } from '@stamhoofd/structures';
+import { Country } from '@stamhoofd/types/Country';
+import { v4 as uuidv4 } from 'uuid';
+import { vi } from 'vitest';
+import { InvoicePdfService } from './InvoicePdfService.js';
+import { InvoiceXMlService } from './InvoiceXMLService.js';
+
+describe('InvoiceXMlService', () => {
+    beforeEach(() => {
+        // The pdf is embedded as base64 in the UBL; avoid the real network download.
+        vi.spyOn(InvoicePdfService, 'downloadPdf').mockResolvedValue(Buffer.from('%PDF-1.4 test'));
+    });
+
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    const belgianAddress = () => Address.create({
+        street: 'Teststraat',
+        number: '1',
+        city: 'Gent',
+        postalCode: '9000',
+        country: Country.Belgium,
+    });
+
+    const seller = () => Company.create({
+        name: 'Seller BV',
+        VATNumber: 'BE0411905847',
+        companyNumber: '0411905847',
+        address: belgianAddress(),
+        administrationEmail: 'billing@seller.be',
+    });
+
+    /**
+     * Builds and persists a minimal, valid invoice for the given customer company, with one
+     * invoiced line, so that InvoiceXMlService.buildXml can generate the UBL.
+     */
+    const buildInvoiceFor = async (company: Company) => {
+        const organization = await new OrganizationFactory({}).create();
+
+        const invoice = new Invoice();
+        invoice.organizationId = organization.id;
+        invoice.number = 'F2026-001';
+        invoice.invoicedAt = new Date(2026, 0, 15);
+        invoice.pdf = new File({ id: uuidv4(), server: 'https://files.example.com', path: 'test.pdf', size: 100, name: 'invoice', contentType: 'application/pdf' });
+        invoice.customer = PaymentCustomer.create({ company });
+        invoice.seller = seller();
+        invoice.totalWithVAT = 12_10;
+        invoice.totalWithoutVAT = 10_00;
+        invoice.VATTotalAmount = 2_10;
+        invoice.payableRoundingAmount = 0;
+        invoice.VATTotal = [VATSubtotal.create({ VATPercentage: 21, taxablePrice: 10_00, VAT: 2_10 })];
+        await invoice.save();
+
+        const balanceItem = await new BalanceItemFactory({ organizationId: organization.id, amount: 1, unitPrice: 10_00 }).create();
+
+        const item = new InvoicedBalanceItem();
+        item.organizationId = organization.id;
+        item.invoiceId = invoice.id;
+        item.balanceItemId = balanceItem.id;
+        item.name = 'Test item';
+        item.unitPrice = 10_00;
+        item.totalWithoutVAT = 10_00;
+        item.quantity = 1_00_00;
+        item.VATPercentage = 21;
+        item.balanceInvoicedAmount = 12_10;
+        await item.save();
+
+        return invoice;
+    };
+
+    test('generates XML for a Belgian company with a VAT number', async () => {
+        const company = Company.create({
+            name: 'Customer BV',
+            VATNumber: 'BE0123456749',
+            companyNumber: '0123456749',
+            address: belgianAddress(),
+        });
+        const invoice = await buildInvoiceFor(company);
+
+        const xml = await InvoiceXMlService.buildXml(invoice);
+
+        expect(xml).toContain('<cbc:Name>Customer BV</cbc:Name>');
+        // No custom PEPPOL id: the endpoint id is the derived KBO number.
+        expect(xml).toContain('<cbc:EndpointID schemeID="0208">0123456749</cbc:EndpointID>');
+        // The legal entity company id is the derived KBO number.
+        expect(xml).toContain('<cbc:CompanyID schemeID="0208">0123456749</cbc:CompanyID>');
+        // The VAT number is registered as a tax scheme.
+        expect(xml).toContain('<cbc:CompanyID>BE0123456749</cbc:CompanyID>');
+    });
+
+    test('generates XML for a Belgian company with only a company number', async () => {
+        const company = Company.create({
+            name: 'Customer VZW',
+            VATNumber: null,
+            companyNumber: '0123456749',
+            address: belgianAddress(),
+        });
+        const invoice = await buildInvoiceFor(company);
+
+        const xml = await InvoiceXMlService.buildXml(invoice);
+
+        expect(xml).toContain('<cbc:Name>Customer VZW</cbc:Name>');
+        expect(xml).toContain('<cbc:EndpointID schemeID="0208">0123456749</cbc:EndpointID>');
+        expect(xml).toContain('<cbc:CompanyID schemeID="0208">0123456749</cbc:CompanyID>');
+        // No VAT number for this company: no customer VAT tax scheme.
+        expect(xml).not.toContain('BE0123456749');
+    });
+
+    test('generates XML for a Belgian company with a VAT number and a custom PEPPOL id', async () => {
+        const company = Company.create({
+            name: 'Customer BV',
+            VATNumber: 'BE0123456749',
+            companyNumber: '0123456749',
+            address: belgianAddress(),
+            customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0088', id: '5412345000013' }),
+        });
+        const invoice = await buildInvoiceFor(company);
+
+        const xml = await InvoiceXMlService.buildXml(invoice);
+
+        // The custom PEPPOL id is used as the delivery endpoint id.
+        expect(xml).toContain('<cbc:EndpointID schemeID="0088">5412345000013</cbc:EndpointID>');
+        // But the legal entity company id remains the derived KBO number.
+        expect(xml).toContain('<cbc:CompanyID schemeID="0208">0123456749</cbc:CompanyID>');
+        expect(xml).toContain('<cbc:CompanyID>BE0123456749</cbc:CompanyID>');
+    });
+
+    test('generates XML for a Belgian company with only a company number and a custom PEPPOL id', async () => {
+        const company = Company.create({
+            name: 'Customer VZW',
+            VATNumber: null,
+            companyNumber: '0123456749',
+            address: belgianAddress(),
+            customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0060', id: '123456789' }),
+        });
+        const invoice = await buildInvoiceFor(company);
+
+        const xml = await InvoiceXMlService.buildXml(invoice);
+
+        expect(xml).toContain('<cbc:EndpointID schemeID="0060">123456789</cbc:EndpointID>');
+        expect(xml).toContain('<cbc:CompanyID schemeID="0208">0123456749</cbc:CompanyID>');
+        expect(xml).not.toContain('BE0123456749');
+    });
+
+    test('cannot generate XML for a company without a company number, even with a custom PEPPOL id', async () => {
+        const company = Company.create({
+            name: 'No Number',
+            VATNumber: null,
+            companyNumber: null,
+            address: belgianAddress(),
+            customPeppolEndpointId: PeppolEndointId.create({ schemeID: '0088', id: '5412345000013' }),
+        });
+        const invoice = await buildInvoiceFor(company);
+
+        // The legal entity company id (peppolCompanyId) requires a VAT or company number,
+        // so a custom endpoint id alone is not enough.
+        await expect(InvoiceXMlService.buildXml(invoice)).rejects.toThrow('Missing customer peppol id');
+    });
+});

package/src/services/InvoiceXMLService.ts

@@ -202,7 +202,7 @@ export class InvoiceXMlService {
                     }
                     <cac:PartyLegalEntity>
                         <cbc:RegistrationName>${esc(company.name)}</cbc:RegistrationName>
-                        <cbc:CompanyID schemeID="0208">${esc(companyNumber)}</cbc:CompanyID>
+                        <cbc:CompanyID schemeID="${esc(customerPeppolCompanyId.schemeID)}">${esc(customerPeppolCompanyId.id)}</cbc:CompanyID>
                     </cac:PartyLegalEntity>
                     ${
                         customerEmail
@@ -398,15 +398,17 @@ export class InvoiceXMlService {
             return;
         }
 
-        if (invoice.customer.company?.VATNumber === null) {
-            console.log('Skipping PEPPOL for invoice ' + invoice.id + ', recipient not subject to VAT');
-            return;
-        }
+        if (!invoice.customer.company?.customPeppolEndpointId) {
+            if (invoice.customer.company?.VATNumber === null) {
+                console.log('Skipping PEPPOL for invoice ' + invoice.id + ', recipient not subject to VAT');
+                return;
+            }
 
-        // Check VAT number is belgian
-        if (!invoice.customer.company?.VATNumber.startsWith('BE')) {
-            console.log('Skipping PEPPOL for invoice ' + invoice.id + ', recipient outside Belgium');
-            return;
+            // Check VAT number is belgian
+            if (!invoice.customer.company?.VATNumber.startsWith('BE')) {
+                console.log('Skipping PEPPOL for invoice ' + invoice.id + ', recipient outside Belgium');
+                return;
+            }
         }
 
         try {

package/src/services/PeppolDirectoryService.test.ts

@@ -0,0 +1,139 @@
+import { PeppolEndointId } from '@stamhoofd/structures';
+import { STExpect } from '@stamhoofd/test-utils';
+import nock from 'nock';
+import { PeppolDirectoryService } from './PeppolDirectoryService.js';
+
+const DIRECTORY_HOST = 'https://directory.peppol.eu';
+const DIRECTORY_PATH = '/search/1.0/json';
+
+describe('PeppolDirectoryService', () => {
+    /**
+     * Mocks the PEPPOL directory search endpoint for a given participant query.
+     * Returns the nock scope so tests can assert whether it was actually called.
+     */
+    function mockDirectory(participant: string, response: unknown, statusCode = 200) {
+        return nock(DIRECTORY_HOST)
+            .get(DIRECTORY_PATH)
+            .query({ participant })
+            .reply(statusCode, response as nock.Body);
+    }
+
+    /**
+     * A directory response that contains a single match for the given participant value.
+     */
+    function matchResponse(value: string) {
+        return {
+            version: '1.0',
+            'total-result-count': 1,
+            matches: [
+                {
+                    participantID: { scheme: 'iso6523-actorid-upis', value },
+                    entities: [{ name: [{ name: 'Demo Company' }], countryCode: 'BE' }],
+                },
+            ],
+        };
+    }
+
+    afterEach(() => {
+        nock.cleanAll();
+        nock.disableNetConnect();
+    });
+
+    test('resolves when the participant is registered in the directory', async () => {
+        const scope = mockDirectory('iso6523-actorid-upis::0208:0123456789', matchResponse('0208:0123456789'));
+
+        const endpointId = PeppolEndointId.create({ schemeID: '0208', id: '0123456789' });
+        await expect(PeppolDirectoryService.validate(endpointId)).resolves.toBeUndefined();
+
+        expect(scope.isDone()).toBe(true);
+        // The registered entity name from the directory is stored on the endpoint id.
+        expect(endpointId.entityName).toBe('Demo Company');
+    });
+
+    test('overwrites a pre-existing entityName with the value from the directory', async () => {
+        mockDirectory('iso6523-actorid-upis::0208:0123456789', matchResponse('0208:0123456789'));
+
+        const endpointId = PeppolEndointId.create({ schemeID: '0208', id: '0123456789', entityName: 'Client supplied name' });
+        await PeppolDirectoryService.validate(endpointId);
+
+        expect(endpointId.entityName).toBe('Demo Company');
+    });
+
+    test('sets entityName to null when the directory match has no entity name', async () => {
+        mockDirectory('iso6523-actorid-upis::0208:0123456789', {
+            'total-result-count': 1,
+            matches: [{ participantID: { scheme: 'iso6523-actorid-upis', value: '0208:0123456789' }, entities: [] }],
+        });
+
+        const endpointId = PeppolEndointId.create({ schemeID: '0208', id: '0123456789', entityName: 'stale' });
+        await PeppolDirectoryService.validate(endpointId);
+
+        expect(endpointId.entityName).toBeNull();
+    });
+
+    test('trims whitespace around the scheme and id before querying', async () => {
+        const scope = mockDirectory('iso6523-actorid-upis::0088:5412345000013', matchResponse('0088:5412345000013'));
+
+        await expect(
+            PeppolDirectoryService.validate(PeppolEndointId.create({ schemeID: ' 0088 ', id: ' 5412345000013 ' })),
+        ).resolves.toBeUndefined();
+
+        expect(scope.isDone()).toBe(true);
+    });
+
+    test('rejects an unsupported scheme without contacting the directory', async () => {
+        const scope = mockDirectory('iso6523-actorid-upis::9999:123', matchResponse('9999:123'));
+
+        await expect(
+            PeppolDirectoryService.validate(PeppolEndointId.create({ schemeID: '9999', id: '123' })),
+        ).rejects.toThrow(STExpect.simpleError({ code: 'invalid_field', field: 'customPeppolEndpointId' }));
+
+        expect(scope.isDone()).toBe(false);
+    });
+
+    test('rejects an empty id without contacting the directory', async () => {
+        const scope = mockDirectory('iso6523-actorid-upis::0208:', matchResponse('0208:'));
+
+        await expect(
+            PeppolDirectoryService.validate(PeppolEndointId.create({ schemeID: '0208', id: '   ' })),
+        ).rejects.toThrow(STExpect.simpleError({ code: 'invalid_field', field: 'customPeppolEndpointId' }));
+
+        expect(scope.isDone()).toBe(false);
+    });
+
+    test('rejects when the participant is not found in the directory', async () => {
+        mockDirectory('iso6523-actorid-upis::0060:123456789', {
+            version: '1.0',
+            'total-result-count': 0,
+            matches: [],
+        });
+
+        await expect(
+            PeppolDirectoryService.validate(PeppolEndointId.create({ schemeID: '0060', id: '123456789' })),
+        ).rejects.toThrow(STExpect.simpleError({ code: 'invalid_field', field: 'customPeppolEndpointId' }));
+    });
+
+    test('rejects when the directory only returns a different participant', async () => {
+        mockDirectory('iso6523-actorid-upis::0208:0123456789', matchResponse('0208:9999999999'));
+
+        await expect(
+            PeppolDirectoryService.validate(PeppolEndointId.create({ schemeID: '0208', id: '0123456789' })),
+        ).rejects.toThrow(STExpect.simpleError({ code: 'invalid_field', field: 'customPeppolEndpointId' }));
+    });
+
+    test('throws service_unavailable when the directory errors out', async () => {
+        mockDirectory('iso6523-actorid-upis::0208:0123456789', { message: 'Internal Server Error' }, 500);
+
+        await expect(
+            PeppolDirectoryService.validate(PeppolEndointId.create({ schemeID: '0208', id: '0123456789' })),
+        ).rejects.toThrow(STExpect.simpleError({ code: 'service_unavailable', field: 'customPeppolEndpointId' }));
+    });
+
+    test('throws service_unavailable when the directory returns an unexpected response', async () => {
+        mockDirectory('iso6523-actorid-upis::0208:0123456789', { unexpected: true });
+
+        await expect(
+            PeppolDirectoryService.validate(PeppolEndointId.create({ schemeID: '0208', id: '0123456789' })),
+        ).rejects.toThrow(STExpect.simpleError({ code: 'service_unavailable', field: 'customPeppolEndpointId' }));
+    });
+});

package/src/services/PeppolDirectoryService.ts

@@ -0,0 +1,111 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import type { PeppolEndointId } from '@stamhoofd/structures';
+import { PeppolScheme } from '@stamhoofd/structures';
+import axios from 'axios';
+
+/**
+ * The PEPPOL schemes (ISO 6523 ICD codes) we currently support for a custom
+ * PEPPOL endpoint id. The scheme identifier is the numeric code used in the
+ * PEPPOL participant identifier (e.g. `iso6523-actorid-upis::0208:...`).
+ */
+export const supportedPeppolSchemes: string[] = Object.values(PeppolScheme);
+
+export class PeppolDirectoryServiceStatic {
+    /**
+     * Validates a custom PEPPOL endpoint id: the scheme must be supported and the
+     * participant must be registered in the PEPPOL directory. Throws a SimpleError
+     * (with field `customPeppolEndpointId`) when the id is invalid or unknown.
+     */
+    async validate(endpointId: PeppolEndointId): Promise<void> {
+        const schemeID = endpointId.schemeID.trim();
+        const id = endpointId.id.trim();
+
+        if (!supportedPeppolSchemes.includes(schemeID)) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Unsupported PEPPOL scheme ' + schemeID,
+                human: $t('%ZcX'),
+                field: 'customPeppolEndpointId',
+            });
+        }
+
+        if (id.length === 0) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Missing PEPPOL endpoint id',
+                human: $t('%ZcY'),
+                field: 'customPeppolEndpointId',
+            });
+        }
+
+        const participant = `iso6523-actorid-upis::${schemeID}:${id}`;
+
+        let data: any;
+        try {
+            const response = await axios.request({
+                method: 'GET',
+                url: 'https://directory.peppol.eu/search/1.0/json',
+                params: { participant },
+            });
+            data = response.data;
+        } catch (e) {
+            // The directory is unavailable: we can't validate the id right now.
+            console.error('PEPPOL directory error', e);
+            throw new SimpleError({
+                code: 'service_unavailable',
+                message: 'PEPPOL directory unavailable',
+                human: $t('%Zcf'),
+                field: 'customPeppolEndpointId',
+            });
+        }
+
+        if (typeof data !== 'object' || data === null || !Array.isArray(data.matches)) {
+            throw new SimpleError({
+                code: 'service_unavailable',
+                message: 'Invalid response from PEPPOL directory',
+                human: $t('%Zcf'),
+                field: 'customPeppolEndpointId',
+            });
+        }
+
+        console.log('PEPPOL lookup', participant, data);
+
+        const expected = `${schemeID}:${id}`.toLowerCase();
+        const match = data.matches.find((m: any) => {
+            return typeof m?.participantID?.value === 'string'
+                && m.participantID.value.toLowerCase() === expected;
+        });
+
+        if (!match) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'PEPPOL participant not found in directory: ' + participant,
+                human: $t('%Zcr', { id: `${schemeID}:${id}` }),
+                field: 'customPeppolEndpointId',
+            });
+        }
+
+        // Store the registered entity name from the directory. This is server-controlled
+        // and overwrites any value the client may have sent (see ViesHelper.checkCompany).
+        endpointId.entityName = this.extractEntityName(match);
+    }
+
+    /**
+     * Best-effort extraction of the registered entity name from a PEPPOL directory match.
+     * The directory returns one or more entities, each with a list of localized names.
+     */
+    private extractEntityName(match: any): string | null {
+        const entities = Array.isArray(match?.entities) ? match.entities : [];
+        for (const entity of entities) {
+            const names = Array.isArray(entity?.name) ? entity.name : [];
+            for (const n of names) {
+                if (typeof n?.name === 'string' && n.name.trim().length > 0) {
+                    return n.name.trim();
+                }
+            }
+        }
+        return null;
+    }
+}
+
+export const PeppolDirectoryService = new PeppolDirectoryServiceStatic();

package/src/services/uitpas/checkPermissionsFor.ts

@@ -74,7 +74,7 @@ export async function checkPermissionsFor(access_token: string, organizationId:
         });
     });
     assertIsPermissionsResponse(json);
-    const neededPermissions = organizationId
+    const neededPermissions = !organizationId
         ? [{
                 permission: 'PASSES_READ',
                 human: 'Basis UiTPAS informatie ophalen met UiTPAS nummer',

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

@@ -1,5 +1,6 @@
 import type { SQLFilterDefinitions } from '@stamhoofd/sql';
-import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { balanceItemFilterCompilers } from './balance-items.js';
 
 export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
@@ -13,59 +14,6 @@ export const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
         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,
-        }),
-        payingOrganizationId: createColumnFilter({
-            expression: SQL.column('balance_items', 'payingOrganizationId'),
-            type: SQLValueType.String,
-            nullable: true,
-        }),
-        type: createColumnFilter({
-            expression: SQL.column('balance_items', 'type'),
-            type: SQLValueType.String,
-            nullable: false,
-        }),
-        registration: createExistsFilter(
-            SQL.select()
-                .from(SQL.table('registrations'))
-                .where(
-                    SQL.column('registrations', 'id'),
-                    SQL.column('balance_items', 'registrationId'),
-                ),
-            {
-                ...baseSQLFilterCompilers,
-                groupId: createColumnFilter({
-                    expression: SQL.column('registrations', 'groupId'),
-                    type: SQLValueType.String,
-                    nullable: false,
-                }),
-            },
-        ),
-        order: createExistsFilter(
-            SQL.select()
-                .from(SQL.table('webshop_orders'))
-                .where(
-                    SQL.column('webshop_orders', 'id'),
-                    SQL.column('balance_items', 'orderId'),
-                ),
-            {
-                ...baseSQLFilterCompilers,
-                webshopId: createColumnFilter({
-                    expression: SQL.column('webshop_orders', 'webshopId'),
-                    type: SQLValueType.String,
-                    nullable: false,
-                }),
-            },
-        ),
-    },
+    // Reuse the shared balance item filters (type, webshop, group, membership type, ...)
+    balanceItem: balanceItemFilterCompilers,
 };

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

@@ -1,56 +1,115 @@
 import type { SQLFilterDefinitions } from '@stamhoofd/sql';
-import { baseSQLFilterCompilers, createColumnFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createExistsFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { BalanceItemRelationType } from '@stamhoofd/structures';
+
+/**
+ * Filters on the relations of a balance item (registration group, webshop order and membership type).
+ *
+ * Grouped separately from the plain column filters because these are JOIN/JSON based rather than simple
+ * columns. They are spread into balanceItemFilterCompilers below, which is the single set consumed both
+ * by the direct balance items endpoint and by the balance items nested inside payments (see
+ * balance-item-payments.ts) — so both automatically expose these relation filters.
+ *
+ * All expressions are qualified with the balance_items table so they keep working when balance_items
+ * is joined into another query (e.g. via balance_item_payments).
+ */
+export const balanceItemRelationFilterCompilers: SQLFilterDefinitions = {
+    registration: createExistsFilter(
+        SQL.select()
+            .from(SQL.table('registrations'))
+            .where(
+                SQL.column('registrations', 'id'),
+                SQL.column('balance_items', 'registrationId'),
+            ),
+        {
+            ...baseSQLFilterCompilers,
+            groupId: createColumnFilter({
+                expression: SQL.column('registrations', 'groupId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+        },
+    ),
+    order: createExistsFilter(
+        SQL.select()
+            .from(SQL.table('webshop_orders'))
+            .where(
+                SQL.column('webshop_orders', 'id'),
+                SQL.column('balance_items', 'orderId'),
+            ),
+        {
+            ...baseSQLFilterCompilers,
+            webshopId: createColumnFilter({
+                expression: SQL.column('webshop_orders', 'webshopId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+        },
+    ),
+    // The membership type is only stored inside the relations JSON, so we read its id from there.
+    membershipType: createColumnFilter({
+        expression: SQL.jsonExtract(SQL.column('balance_items', 'relations'), `$.value.${BalanceItemRelationType.MembershipType}.id`),
+        type: SQLValueType.JSONString,
+        nullable: true,
+    }),
+};
 
 /**
  * Defines how to filter balance items in the database from StamhoofdFilter objects
  */
 export const balanceItemFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
+    ...balanceItemRelationFilterCompilers,
     id: createColumnFilter({
-        expression: SQL.column('id'),
+        expression: SQL.column('balance_items', 'id'),
         type: SQLValueType.String,
         nullable: false,
     }),
     organizationId: createColumnFilter({
-        expression: SQL.column('organizationId'),
+        expression: SQL.column('balance_items', 'organizationId'),
         type: SQLValueType.String,
         nullable: false,
     }),
+    payingOrganizationId: createColumnFilter({
+        expression: SQL.column('balance_items', 'payingOrganizationId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     type: createColumnFilter({
-        expression: SQL.column('type'),
+        expression: SQL.column('balance_items', 'type'),
         type: SQLValueType.String,
         nullable: false,
     }),
     status: createColumnFilter({
-        expression: SQL.column('status'),
+        expression: SQL.column('balance_items', 'status'),
         type: SQLValueType.String,
         nullable: false,
     }),
     createdAt: createColumnFilter({
-        expression: SQL.column('createdAt'),
+        expression: SQL.column('balance_items', 'createdAt'),
         type: SQLValueType.Datetime,
         nullable: false,
     }),
     updatedAt: createColumnFilter({
-        expression: SQL.column('updatedAt'),
+        expression: SQL.column('balance_items', 'updatedAt'),
         type: SQLValueType.Datetime,
         nullable: false,
     }),
 
     description: createColumnFilter({
-        expression: SQL.column('description'),
+        expression: SQL.column('balance_items', 'description'),
         type: SQLValueType.String,
         nullable: false,
     }),
 
     priceWithVAT: createColumnFilter({
-        expression: SQL.column('priceTotal'),
+        expression: SQL.column('balance_items', 'priceTotal'),
         type: SQLValueType.Number,
         nullable: false,
     }),
 
     priceOpen: createColumnFilter({
-        expression: SQL.column('priceOpen'),
+        expression: SQL.column('balance_items', 'priceOpen'),
         type: SQLValueType.Number,
         nullable: false,
     }),