@stamhoofd/backend 2.122.7 → 2.122.9

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.122.7",
+    "version": "2.122.9",
     "type": "module",
     "main": "./dist/index.js",
     "exports": {
@@ -57,20 +57,20 @@
         "@simonbackx/simple-endpoints": "1.21.1",
         "@simonbackx/simple-errors": "1.5.0",
         "@simonbackx/simple-logging": "1.0.1",
-        "@stamhoofd/backend-env": "2.122.7",
-        "@stamhoofd/backend-i18n": "2.122.7",
-        "@stamhoofd/backend-middleware": "2.122.7",
-        "@stamhoofd/crons": "2.122.7",
-        "@stamhoofd/email": "2.122.7",
-        "@stamhoofd/excel-writer": "2.122.7",
-        "@stamhoofd/logging": "2.122.7",
-        "@stamhoofd/models": "2.122.7",
-        "@stamhoofd/object-differ": "2.122.7",
-        "@stamhoofd/queues": "2.122.7",
-        "@stamhoofd/sql": "2.122.7",
-        "@stamhoofd/structures": "2.122.7",
-        "@stamhoofd/types": "2.122.7",
-        "@stamhoofd/utility": "2.122.7",
+        "@stamhoofd/backend-env": "2.122.9",
+        "@stamhoofd/backend-i18n": "2.122.9",
+        "@stamhoofd/backend-middleware": "2.122.9",
+        "@stamhoofd/crons": "2.122.9",
+        "@stamhoofd/email": "2.122.9",
+        "@stamhoofd/excel-writer": "2.122.9",
+        "@stamhoofd/logging": "2.122.9",
+        "@stamhoofd/models": "2.122.9",
+        "@stamhoofd/object-differ": "2.122.9",
+        "@stamhoofd/queues": "2.122.9",
+        "@stamhoofd/sql": "2.122.9",
+        "@stamhoofd/structures": "2.122.9",
+        "@stamhoofd/types": "2.122.9",
+        "@stamhoofd/utility": "2.122.9",
         "archiver": "7.0.1",
         "axios": "1.16.0",
         "base-x": "3.0.11",
@@ -91,7 +91,7 @@
         "stripe": "16.12.0"
     },
     "devDependencies": {
-        "@stamhoofd/test-utils": "2.122.7",
+        "@stamhoofd/test-utils": "2.122.9",
         "@types/cookie": "0.6.0",
         "@types/luxon": "3.7.1",
         "@types/mailparser": "3.4.6",
@@ -107,5 +107,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "2fcad274db9243e6eea1ab70a63046b949608e2a"
+    "gitHead": "f3f81008f51b26e7eb368643a05995f70cfad327"
 }

package/src/endpoints/organization/dashboard/registration-periods/MoveRegistrationPeriods.test.ts

@@ -1,7 +1,7 @@
 import { Request } from '@simonbackx/simple-endpoints';
 import type { Organization, OrganizationRegistrationPeriod, RegistrationPeriod } from '@stamhoofd/models';
 import { GroupFactory, MemberFactory, OrganizationFactory, OrganizationRegistrationPeriodFactory, Registration, RegistrationFactory, RegistrationPeriodFactory, Token, UserFactory } from '@stamhoofd/models';
-import { Group, GroupType, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, PermissionLevel, Permissions, PermissionsResourceType, ResourcePermissions, Version } from '@stamhoofd/structures';
+import { Group, GroupCategory, GroupCategorySettings, GroupType, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, OrganizationRegistrationPeriodSettings, PermissionLevel, Permissions, PermissionsResourceType, ResourcePermissions, Version } from '@stamhoofd/structures';
 import { PatchOrganizationRegistrationPeriodsEndpoint } from './PatchOrganizationRegistrationPeriodsEndpoint.js';
 
 import type { PatchableArrayAutoEncoder } from '@simonbackx/simple-encoding';
@@ -486,3 +486,228 @@ describe('Endpoint.PatchOrganizationRegistrationPeriodsEndpoint.MoveRegistration
         });
     });
 });
+
+describe('Endpoint.PatchOrganizationRegistrationPeriodsEndpoint.MoveCategoryToPeriod', () => {
+    let organization: Organization;
+    let token: Token;
+
+    beforeEach(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+    });
+
+    beforeAll(async () => {
+        TestUtils.setEnvironment('userMode', 'platform');
+        const period = await new RegistrationPeriodFactory({}).create();
+        organization = await new OrganizationFactory({ period }).create();
+
+        const user = await new UserFactory({
+            organization,
+            permissions: Permissions.create({
+                level: PermissionLevel.Full,
+            }),
+        }).create();
+        token = await Token.createToken(user);
+    });
+
+    const patchOrganizationRegistrationPeriods = async ({ patch }: { patch: PatchableArrayAutoEncoder<OrganizationRegistrationPeriodStruct> }) => {
+        const request = Request.buildJson('PATCH', `/v${Version}/organization/registration-periods`, organization.getApiHost(), patch);
+        request.headers.authorization = 'Bearer ' + token.accessToken;
+        return await testServer.test(endpoint, request);
+    };
+
+    /**
+     * Creates an organization period with a single top-level category (under the root) holding the given groups.
+     */
+    const createPeriodWithCategory = async (groupIds: string[]) => {
+        const period = await new RegistrationPeriodFactory({}).create();
+        const organizationPeriod = await new OrganizationRegistrationPeriodFactory({ organization, period }).create();
+
+        const category = GroupCategory.create({
+            settings: GroupCategorySettings.create({ name: 'Movable category' }),
+            groupIds,
+        });
+
+        const root = organizationPeriod.settings.rootCategory!;
+        root.categoryIds = [category.id];
+        organizationPeriod.settings.categories = [root, category];
+        await organizationPeriod.save();
+
+        return { period, organizationPeriod, category };
+    };
+
+    /**
+     * Builds the patch the frontend (useGroupCategoryActions.moveToOtherPeriod) sends:
+     * the category and all its descendants are added to the destination, the groups are moved,
+     * and the category is removed from its parent in the source period.
+     */
+    const buildMovePatch = ({ source, destination, categories, topCategoryId, groupIds, destinationPeriodId }: {
+        source: OrganizationRegistrationPeriod;
+        destination: OrganizationRegistrationPeriod;
+        categories: GroupCategory[];
+        topCategoryId: string;
+        groupIds: string[];
+        destinationPeriodId: string;
+    }) => {
+        const body = new PatchableArray() as PatchableArrayAutoEncoder<OrganizationRegistrationPeriodStruct>;
+
+        const destinationSettings = OrganizationRegistrationPeriodSettings.patch({});
+        for (const category of categories) {
+            destinationSettings.categories.addPut(category);
+        }
+        const destinationParent = GroupCategory.patch({ id: destination.settings.rootCategoryId });
+        destinationParent.categoryIds.addPut(topCategoryId);
+        destinationSettings.categories.addPatch(destinationParent);
+
+        const destinationPatch = OrganizationRegistrationPeriodStruct.patch({ id: destination.id, settings: destinationSettings });
+        for (const groupId of groupIds) {
+            destinationPatch.groups.addPatch(Group.patch({ id: groupId, periodId: destinationPeriodId }));
+        }
+
+        const sourceSettings = OrganizationRegistrationPeriodSettings.patch({});
+        const sourceParent = GroupCategory.patch({ id: source.settings.rootCategoryId });
+        sourceParent.categoryIds.addDelete(topCategoryId);
+        sourceSettings.categories.addPatch(sourceParent);
+        const sourcePatch = OrganizationRegistrationPeriodStruct.patch({ id: source.id, settings: sourceSettings });
+
+        // Order is important: the destination patch moves the groups first, then the source is cleaned up
+        body.addPatch(destinationPatch);
+        body.addPatch(sourcePatch);
+
+        return body;
+    };
+
+    test('Moving a category with a group to another period', async () => {
+        const group = await new GroupFactory({ organization }).create();
+        const member = await new MemberFactory({ organization }).create();
+        const registration = await new RegistrationFactory({ group, member }).create();
+
+        const { organizationPeriod: source, category } = await createPeriodWithCategory([group.id]);
+
+        const destinationPeriod = await new RegistrationPeriodFactory({}).create();
+        const destination = await new OrganizationRegistrationPeriodFactory({ organization, period: destinationPeriod }).create();
+
+        const body = buildMovePatch({
+            source,
+            destination,
+            categories: [category],
+            topCategoryId: category.id,
+            groupIds: [group.id],
+            destinationPeriodId: destinationPeriod.id,
+        });
+
+        const result = await patchOrganizationRegistrationPeriods({ patch: body });
+
+        const destinationResult = result.body.find(p => p.id === destination.id)!;
+        const sourceResult = result.body.find(p => p.id === source.id)!;
+
+        // Category and group are now in the destination period
+        expect(destinationResult.settings.categories.find(c => c.id === category.id)).toBeDefined();
+        expect(destinationResult.settings.rootCategory?.categoryIds).toContain(category.id);
+        const movedGroup = destinationResult.groups.find(g => g.id === group.id);
+        expect(movedGroup).toBeDefined();
+        expect(movedGroup!.periodId).toBe(destinationPeriod.id);
+
+        // Category and group are removed from the source period
+        expect(sourceResult.settings.categories.find(c => c.id === category.id)).toBeUndefined();
+        expect(sourceResult.settings.rootCategory?.categoryIds ?? []).not.toContain(category.id);
+        expect(sourceResult.groups.find(g => g.id === group.id)).toBeUndefined();
+
+        // The registration in the group is also moved to the destination period
+        const updatedRegistration = await Registration.getByID(registration.id);
+        expect(updatedRegistration!.periodId).toBe(destinationPeriod.id);
+    });
+
+    test('Moving a category also moves its nested subcategories', async () => {
+        const period = await new RegistrationPeriodFactory({}).create();
+        const source = await new OrganizationRegistrationPeriodFactory({ organization, period }).create();
+        const group = await new GroupFactory({ organization, period }).create();
+
+        // root -> parent -> child(group)
+        const child = GroupCategory.create({
+            settings: GroupCategorySettings.create({ name: 'Child' }),
+            groupIds: [group.id],
+        });
+        const parent = GroupCategory.create({
+            settings: GroupCategorySettings.create({ name: 'Parent' }),
+            categoryIds: [child.id],
+        });
+        const root = source.settings.rootCategory!;
+        root.categoryIds = [parent.id];
+        source.settings.categories = [root, parent, child];
+        await source.save();
+
+        const destinationPeriod = await new RegistrationPeriodFactory({}).create();
+        const destination = await new OrganizationRegistrationPeriodFactory({ organization, period: destinationPeriod }).create();
+
+        const body = buildMovePatch({
+            source,
+            destination,
+            categories: [parent, child],
+            topCategoryId: parent.id,
+            groupIds: [group.id],
+            destinationPeriodId: destinationPeriod.id,
+        });
+
+        const result = await patchOrganizationRegistrationPeriods({ patch: body });
+
+        const destinationResult = result.body.find(p => p.id === destination.id)!;
+        const sourceResult = result.body.find(p => p.id === source.id)!;
+
+        // The whole subtree is now in the destination period
+        expect(destinationResult.settings.rootCategory?.categoryIds).toContain(parent.id);
+        expect(destinationResult.settings.categories.find(c => c.id === parent.id)?.categoryIds).toContain(child.id);
+        expect(destinationResult.settings.categories.find(c => c.id === child.id)?.groupIds).toContain(group.id);
+        expect(destinationResult.groups.find(g => g.id === group.id)?.periodId).toBe(destinationPeriod.id);
+
+        // Nothing is left behind in the source period
+        expect(sourceResult.settings.categories.find(c => c.id === parent.id)).toBeUndefined();
+        expect(sourceResult.settings.categories.find(c => c.id === child.id)).toBeUndefined();
+        expect(sourceResult.groups.find(g => g.id === group.id)).toBeUndefined();
+    });
+
+    test('Moving towards a locked period is blocked', async () => {
+        const period = await new RegistrationPeriodFactory({}).create();
+        const source = await new OrganizationRegistrationPeriodFactory({ organization, period }).create();
+        const group = await new GroupFactory({ organization, period }).create();
+
+        // root -> parent -> child(group)
+        const child = GroupCategory.create({
+            settings: GroupCategorySettings.create({ name: 'Child' }),
+            groupIds: [group.id],
+        });
+        const parent = GroupCategory.create({
+            settings: GroupCategorySettings.create({ name: 'Parent' }),
+            categoryIds: [child.id],
+        });
+        const root = source.settings.rootCategory!;
+        root.categoryIds = [parent.id];
+        source.settings.categories = [root, parent, child];
+        await source.save();
+
+        const destinationPeriod = await new RegistrationPeriodFactory({}).create();
+
+        const destination = await new OrganizationRegistrationPeriodFactory({ organization, period: destinationPeriod }).create();
+
+        const body = buildMovePatch({
+            source,
+            destination,
+            categories: [parent, child],
+            topCategoryId: parent.id,
+            groupIds: [group.id],
+            destinationPeriodId: destinationPeriod.id,
+        });
+        destinationPeriod.locked = true;
+        await destinationPeriod.save();
+        expect(group.periodId).toEqual(period.id);
+
+        await expect(patchOrganizationRegistrationPeriods({ patch: body })).rejects.toThrow(STExpect.simpleError({
+            code: 'locked_period',
+        }));
+
+        // Check nothing moved
+        await group.refresh();
+        await source.refresh();
+        expect(group.periodId).toEqual(period.id);
+        expect(source.settings.categories).toEqual([root, parent, child]);
+    });
+});

package/src/helpers/AdminPermissionChecker.ts

@@ -209,6 +209,14 @@ export class AdminPermissionChecker {
         return this.user.permissions.organizationPermissions.get(typeof organizationOrId === 'string' ? organizationOrId : organizationOrId.id) ?? null;
     }
 
+    getUnloadedPlatformPermissions() {
+        if (!this.user.permissions) {
+            return null;
+        }
+
+        return this.user.permissions.globalPermissions;
+    }
+
     async canAccessPrivateOrganizationData(organization: Organization) {
         if (!this.checkScope(organization.id)) {
             return false;
@@ -232,7 +240,7 @@ export class AdminPermissionChecker {
             return false;
         }
 
-        if (!await this.hasSomeUnloadedAccess(organization)) {
+        if (!await this.hasSomeUnloadedAccess(organization) && !this.hasSomeUnloadedPlatformAccess()) {
             return false;
         }
         return true;
@@ -1130,6 +1138,11 @@ export class AdminPermissionChecker {
         return !!unloadedPermissions && !unloadedPermissions.isEmpty;
     }
 
+    hasSomeUnloadedPlatformAccess(): boolean {
+        const unloadedPermissions = this.getUnloadedPlatformPermissions();
+        return !!unloadedPermissions && !unloadedPermissions.isEmpty;
+    }
+
     async canManageAdmins(organizationId: string) {
         return !this.user.isApiUser && (await this.hasFullAccess(organizationId));
     }

package/src/helpers/ViesHelper.test.ts

@@ -0,0 +1,257 @@
+import { Address, Company } from '@stamhoofd/structures';
+import { STExpect, TestUtils } from '@stamhoofd/test-utils';
+import { Country } from '@stamhoofd/types/Country';
+import nock from 'nock';
+import { ViesHelper } from './ViesHelper.js';
+
+const VIES_HOST = 'https://ec.europa.eu';
+const VIES_PATH = '/taxation_customs/vies/rest-api/check-vat-number';
+
+describe('ViesHelper', () => {
+    /**
+     * Registers a mock for the (only) external dependency: the VIES check-vat-number endpoint.
+     * Returns the nock scope so tests can assert whether it was actually called.
+     */
+    function mockVies(response: unknown, statusCode = 200) {
+        return nock(VIES_HOST).post(VIES_PATH).reply(statusCode, response as nock.Body);
+    }
+
+    /**
+     * Captures the JSON body that was sent to the VIES endpoint, so we can assert
+     * what we send without depending on the internals of the helper.
+     */
+    function mockViesCapturingBody(response: unknown, statusCode = 200): { getBody: () => any } {
+        let body: any;
+        nock(VIES_HOST)
+            .post(VIES_PATH, (requestBody) => {
+                body = requestBody;
+                return true;
+            })
+            .reply(statusCode, response as nock.Body);
+        return { getBody: () => body };
+    }
+
+    afterEach(() => {
+        nock.cleanAll();
+        nock.disableNetConnect();
+    });
+
+    describe('checkVATNumber', () => {
+        describe('rejects invalid numbers before contacting the API', () => {
+            test('an invalid Belgian VAT number is rejected without a request', async () => {
+                const scope = mockVies({ valid: true });
+
+                await expect(ViesHelper.checkVATNumber(Country.Belgium, 'BE0123')).rejects.toThrow(
+                    STExpect.simpleError({ code: 'invalid_field', field: 'VATNumber' }),
+                );
+
+                // The VIES endpoint must not have been called.
+                expect(scope.isDone()).toBe(false);
+            });
+
+            test('an invalid Dutch VAT number is rejected without a request', async () => {
+                const scope = mockVies({ valid: true });
+
+                await expect(ViesHelper.checkVATNumber(Country.Netherlands, 'NL123456789B01')).rejects.toThrow(
+                    STExpect.simpleError({ code: 'invalid_field', field: 'VATNumber' }),
+                );
+
+                expect(scope.isDone()).toBe(false);
+            });
+
+            test('garbage input is rejected without a request', async () => {
+                const scope = mockVies({ valid: true });
+
+                await expect(ViesHelper.checkVATNumber(Country.Belgium, 'not-a-vat-number')).rejects.toThrow(
+                    STExpect.simpleError({ code: 'invalid_field', field: 'VATNumber' }),
+                );
+
+                expect(scope.isDone()).toBe(false);
+            });
+
+            test('the error message contains the rejected number', async () => {
+                await expect(ViesHelper.checkVATNumber(Country.Belgium, 'BE0123')).rejects.toThrow(
+                    STExpect.simpleError({ code: 'invalid_field', field: 'VATNumber', message: /Ongeldig BTW-nummer.*BE0123/ }),
+                );
+            });
+        });
+
+        describe('parses the API response', () => {
+            test('returns the formatted number when VIES confirms it is valid', async () => {
+                const scope = mockVies({ valid: true });
+
+                await expect(ViesHelper.checkVATNumber(Country.Belgium, 'BE0411905847')).resolves.toBe('BE0411905847');
+
+                // The number was actually validated against VIES.
+                expect(scope.isDone()).toBe(true);
+            });
+
+            test('sends the country code and the cleaned number (without country prefix) to VIES', async () => {
+                const mock = mockViesCapturingBody({ valid: true });
+
+                await ViesHelper.checkVATNumber(Country.Belgium, 'BE0411905847');
+
+                expect(mock.getBody()).toEqual({
+                    countryCode: 'BE',
+                    vatNumber: '0411905847',
+                });
+            });
+
+            test('validates Dutch numbers against VIES as well', async () => {
+                const mock = mockViesCapturingBody({ valid: true });
+
+                await expect(ViesHelper.checkVATNumber(Country.Netherlands, 'NL301828519B01')).resolves.toBe('NL301828519B01');
+
+                expect(mock.getBody()).toEqual({
+                    countryCode: 'NL',
+                    vatNumber: '301828519B01',
+                });
+            });
+
+            test('throws an invalid_field error when VIES reports the number as not valid', async () => {
+                mockVies({ valid: false });
+
+                await expect(ViesHelper.checkVATNumber(Country.Belgium, 'BE0411905847')).rejects.toThrow(
+                    STExpect.simpleError({
+                        code: 'invalid_field',
+                        field: 'VATNumber',
+                        message: /BTW-plichtig.*BE0411905847/,
+                    }),
+                );
+            });
+
+            test('throws service_unavailable when VIES returns a response without a valid boolean', async () => {
+                mockVies({ somethingElse: true });
+
+                await expect(ViesHelper.checkVATNumber(Country.Belgium, 'BE0411905847')).rejects.toThrow(
+                    STExpect.simpleError({ code: 'service_unavailable', field: 'VATNumber' }),
+                );
+            });
+
+            test('throws service_unavailable when VIES returns a non-object response', async () => {
+                mockVies('"plain string"');
+
+                await expect(ViesHelper.checkVATNumber(Country.Belgium, 'BE0411905847')).rejects.toThrow(
+                    STExpect.simpleError({ code: 'service_unavailable', field: 'VATNumber' }),
+                );
+            });
+
+            test('throws service_unavailable when the VIES endpoint errors out', async () => {
+                mockVies({ message: 'Internal Server Error' }, 500);
+
+                await expect(ViesHelper.checkVATNumber(Country.Belgium, 'BE0411905847')).rejects.toThrow(
+                    STExpect.simpleError({ code: 'service_unavailable', field: 'VATNumber' }),
+                );
+            });
+        });
+
+        test('skips the API in development for the known development number', async () => {
+            TestUtils.setEnvironment('environment', 'development');
+            const scope = mockVies({ valid: false });
+
+            await expect(ViesHelper.checkVATNumber(Country.Netherlands, 'NL301828519B01')).resolves.toBe('NL301828519B01');
+
+            // No request was made, even though VIES would have reported it invalid.
+            expect(scope.isDone()).toBe(false);
+        });
+    });
+
+    describe('checkCompanyNumber', () => {
+        test('returns the number unchanged for non-Belgian countries without contacting the API', async () => {
+            const scope = mockVies({ valid: true });
+
+            const result = await ViesHelper.checkCompanyNumber(Country.Netherlands, '12345678');
+
+            expect(result).toEqual({ companyNumber: '12345678' });
+            expect(scope.isDone()).toBe(false);
+        });
+
+        test('rejects an invalid Belgian company number without contacting the API', async () => {
+            const scope = mockVies({ valid: true });
+
+            await expect(ViesHelper.checkCompanyNumber(Country.Belgium, '123')).rejects.toThrow(
+                STExpect.simpleError({ code: 'invalid_field', field: 'companyNumber', message: /Ongeldig ondernemingsnummer: 123/ }),
+            );
+
+            expect(scope.isDone()).toBe(false);
+        });
+
+        test('promotes a valid Belgian company number to a VAT number when VIES confirms it', async () => {
+            mockVies({ valid: true });
+
+            const result = await ViesHelper.checkCompanyNumber(Country.Belgium, '0411905847');
+
+            expect(result).toEqual({
+                companyNumber: '0411905847',
+                VATNumber: 'BE0411905847',
+            });
+        });
+
+        test('keeps the company number but clears the VAT number when VIES does not recognise it', async () => {
+            mockVies({ valid: false });
+
+            const result = await ViesHelper.checkCompanyNumber(Country.Belgium, '0411905847');
+
+            expect(result).toEqual({
+                companyNumber: '0411905847',
+                VATNumber: null,
+            });
+        });
+    });
+
+    describe('checkCompany', () => {
+        const belgianAddress = () => Address.create({
+            street: 'Demostraat',
+            number: '12',
+            city: 'Gent',
+            postalCode: '9000',
+            country: Country.Belgium,
+        });
+
+        test('clears both numbers when the company has no address, without contacting the API', async () => {
+            const scope = mockVies({ valid: true });
+
+            const company = Company.create({
+                name: 'Demo Company',
+                VATNumber: 'BE0411905847',
+                companyNumber: '0411905847',
+                address: null,
+            });
+            const patch = Company.create({});
+
+            await ViesHelper.checkCompany(company, patch);
+
+            expect(patch.VATNumber).toBeNull();
+            expect(patch.companyNumber).toBeNull();
+            expect(scope.isDone()).toBe(false);
+        });
+
+        test('rejects a company name that is too short', async () => {
+            const company = Company.create({
+                name: 'ab',
+                address: belgianAddress(),
+            });
+
+            await expect(ViesHelper.checkCompany(company, Company.create({}))).rejects.toThrow(
+                STExpect.simpleError({ code: 'invalid_company_name', field: 'companyName' }),
+            );
+        });
+
+        test('validates the VAT number and derives the company number for a Belgian company', async () => {
+            mockVies({ valid: true });
+
+            const company = Company.create({
+                name: 'Demo Company',
+                VATNumber: 'BE0411905847',
+                companyNumber: null,
+                address: belgianAddress(),
+            });
+            const patch = Company.create({});
+
+            await ViesHelper.checkCompany(company, patch);
+
+            expect(patch.VATNumber).toBe('BE0411905847');
+            expect(patch.companyNumber).toBe('0411905847');
+        });
+    });
+});

package/src/helpers/ViesHelper.ts

@@ -3,7 +3,7 @@ import { isSimpleError, isSimpleErrors, SimpleError } from '@simonbackx/simple-e
 import type { Company } from '@stamhoofd/structures';
 import { Country } from '@stamhoofd/types/Country';
 import axios from 'axios';
-import * as jsvat from 'jsvat-next'; // has no default export, so we need the wildcard
+import jsvat from 'jsvat-next';
 
 export class ViesHelperStatic {
     testMode = false;