@stamhoofd/backend 2.137.4 → 2.138.0

package/src/middleware/TenantScopeMiddleware.test.ts

@@ -0,0 +1,41 @@
+import type { DecodedRequest } from '@simonbackx/simple-endpoints';
+import { Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { ROOT_TENANT_ID } from '@stamhoofd/models';
+import { testServer } from '../../tests/helpers/TestServer.js';
+import { TenantContext } from '../helpers/TenantContext.js';
+
+type Params = Record<string, never>;
+
+/**
+ * Reports the tenant scope it was reached in, so a request can assert what the middleware set up.
+ */
+class TenantProbeEndpoint extends Endpoint<Params, undefined, undefined, string> {
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET' || request.url !== '/tenant-probe') {
+            return [false];
+        }
+        return [true, {}];
+    }
+
+    async handle(_request: DecodedRequest<Params, undefined, undefined>) {
+        return new Response(TenantContext.optional?.tenantId ?? 'no-tenant');
+    }
+}
+
+describe('TenantScopeMiddleware', () => {
+    test('a request runs in a tenant scope', async () => {
+        const endpoint = new TenantProbeEndpoint();
+
+        const response = await testServer.test(endpoint, Request.buildJson('GET', '/tenant-probe', 'localhost'));
+
+        expect(response.body).toBe(ROOT_TENANT_ID);
+    });
+
+    test('the scope does not outlive the request', async () => {
+        const endpoint = new TenantProbeEndpoint();
+
+        await testServer.test(endpoint, Request.buildJson('GET', '/tenant-probe', 'localhost'));
+
+        expect(TenantContext.optional).toBeNull();
+    });
+});

package/src/middleware/TenantScopeMiddleware.ts

@@ -0,0 +1,24 @@
+import type { Request, RequestMiddleware } from '@simonbackx/simple-endpoints';
+import { ROOT_TENANT_ID } from '@stamhoofd/models';
+
+import { TenantContext } from '../helpers/TenantContext.js';
+
+/**
+ * Puts every request in a tenant scope.
+ *
+ * Every request resolves to the deployment's root tenant for now. Resolving it from the host is a
+ * later step; this exists so the scope is already there when it starts to matter.
+ *
+ * Register this *after* ContextMiddleware: wrapRun wrappers are applied in registration order, so
+ * the last one registered is the outermost. The tenant has to be in scope before the context that
+ * reads it.
+ */
+export const TenantScopeMiddleware: RequestMiddleware = {
+    wrapRun<T>(run: () => Promise<T>, _request: Request) {
+        return TenantContext.run(ROOT_TENANT_ID, run);
+    },
+
+    handleRequest() {
+        // Noop
+    },
+};

package/src/seeds/1785417302-fill-user-last-active-at.sql

@@ -0,0 +1,6 @@
+UPDATE `users` u
+SET u.lastActiveAt = (
+    SELECT MAX(t.updatedAt)
+    FROM tokens t
+    WHERE t.userId = u.id
+);

package/src/services/AdminSessionService.ts

@@ -0,0 +1,41 @@
+import { Token, User } from '@stamhoofd/models';
+
+/**
+ * Signs out administrators in bulk.
+ *
+ * Making two-factor authentication required only affects new logins: it is evaluated when a
+ * session is created, so admins that are already signed in keep their session and never get
+ * asked to enroll. An administrator can therefore ask us to end those sessions, which forces
+ * every other admin through the login flow again — and with that through the forced
+ * enrollment.
+ *
+ * API users are never signed out: their tokens are machine credentials with a long lifetime
+ * that cannot complete an interactive login. User.getAdmins()/getPlatformAdmins() already
+ * leave them out.
+ */
+export class AdminSessionService {
+    /**
+     * Sign out every administrator of an organization.
+     *
+     * `keepAccessToken` is the session of the administrator making the request: signing
+     * themselves out would interrupt what they are doing, and they are forced to enroll on
+     * their next login anyway.
+     *
+     * Returns the number of ended sessions.
+     */
+    static async signOutOrganizationAdmins(organizationId: string, keepAccessToken: string | null): Promise<number> {
+        const admins = await User.getAdmins(organizationId);
+        return await Token.deleteForUsers(admins.map(a => a.id), keepAccessToken);
+    }
+
+    /**
+     * Sign out every administrator of the platform. Administrators that only have
+     * permissions within an organization are not affected.
+     *
+     * Returns the number of ended sessions.
+     */
+    static async signOutPlatformAdmins(keepAccessToken: string | null): Promise<number> {
+        const admins = await User.getPlatformAdmins();
+        return await Token.deleteForUsers(admins.map(a => a.id), keepAccessToken);
+    }
+}

package/src/services/BalanceItemService.ts

@@ -7,6 +7,7 @@ import { Formatter } from '@stamhoofd/utility';
 import { GroupedThrottledQueue } from '../helpers/GroupedThrottledQueue.js';
 import { ThrottledQueue } from '../helpers/ThrottledQueue.js';
 import { AuditLogService } from './AuditLogService.js';
+import { OrderService } from './OrderService.js';
 import { PaymentReallocationService } from './PaymentReallocationService.js';
 import { RegistrationService } from './RegistrationService.js';
 import { STPackageService } from './STPackageService.js';
@@ -235,7 +236,7 @@ export class BalanceItemService {
             const order = await Order.getByID(balanceItem.orderId);
             if (order) {
                 shouldMarkUpdated = false;
-                await order.markPaid(payment, organization);
+                await OrderService.markPaid(order, payment, organization);
 
                 // Save number in balance description
                 if (order.number !== null) {

package/src/services/DocumentRenderService.test.ts

@@ -0,0 +1,229 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Document, DocumentTemplateFactory, Organization } from '@stamhoofd/models';
+import { Address, DocumentData, DocumentStatus, File, Image, OrganizationMetaData, PlatformConfig, Platform as PlatformStruct, RecordSettings, RecordTextAnswer, RecordType } from '@stamhoofd/structures';
+import { Country } from '@stamhoofd/types/Country';
+import { DocumentRenderService } from './DocumentRenderService.js';
+
+function createImage(id: string) {
+    return Image.create({
+        id,
+        source: new File({
+            id,
+            server: 'https://files.example.com',
+            path: id + '.png',
+            size: 100,
+        }),
+    });
+}
+
+/**
+ * An organization that is not saved in the database: enough to build a context with.
+ */
+function createOrganization(meta?: Partial<{ horizontalLogo: Image | null; squareLogo: Image | null }>) {
+    const organization = new Organization();
+    organization.name = 'Test organization';
+    organization.meta = OrganizationMetaData.create({
+        horizontalLogo: meta?.horizontalLogo ?? null,
+        squareLogo: meta?.squareLogo ?? null,
+    });
+    organization.address = Address.create({
+        street: 'Demostraat',
+        number: '12',
+        city: 'Gent',
+        postalCode: '9000',
+        country: Country.Belgium,
+    });
+    return organization;
+}
+
+function createDocument() {
+    const document = new Document();
+    document.data = DocumentData.create({ name: 'Test document' });
+    return document;
+}
+
+function createPlatform(config: Partial<{ logoDocuments: Image | null; horizontalLogo: Image | null; squareLogo: Image | null }>) {
+    return PlatformStruct.create({
+        config: PlatformConfig.create({
+            logoDocuments: config.logoDocuments ?? null,
+            horizontalLogo: config.horizontalLogo ?? null,
+            squareLogo: config.squareLogo ?? null,
+        }),
+    });
+}
+
+/**
+ * An answer that cannot be mapped onto the context object, so building the context throws.
+ */
+function createInvalidFieldAnswers() {
+    return new Map([
+        ['', RecordTextAnswer.create({
+            settings: RecordSettings.create({ id: '', type: RecordType.Text }),
+            value: 'Some value',
+        })],
+    ]);
+}
+
+const xmlExport = '<documents>{{#each documents}}<document>{{{this.number}}}</document>{{/each}}</documents>';
+
+/**
+ * Builds a locked template: a locked template makes buildAll return the documents unchanged, so the
+ * numbers set up here are exactly what the renumbering logic gets to see.
+ */
+async function createTemplateWithDocuments(numbers: number[], options?: { xmlExport?: string | null; lockDocuments?: boolean }) {
+    const template = await new DocumentTemplateFactory({
+        groups: [],
+        status: DocumentStatus.Published,
+    }).createWithoutSave();
+
+    template.privateSettings.templateDefinition.xmlExport = options?.xmlExport === undefined ? xmlExport : options.xmlExport;
+    await template.save();
+
+    const documents: Document[] = [];
+    for (const number of numbers) {
+        const document = new Document();
+        document.organizationId = template.organizationId;
+        document.templateId = template.id;
+        document.status = DocumentStatus.Published;
+        document.number = number;
+        document.data = DocumentData.create({ name: 'Test document' });
+        await document.save();
+
+        if (options?.lockDocuments) {
+            document.isLocked = true;
+            await document.save({ forceSave: true });
+        }
+        documents.push(document);
+    }
+
+    // Lock last: a locked template can no longer be saved normally
+    template.isLocked = true;
+    await template.save({ forceSave: true });
+
+    const organization = (await Organization.getByID(template.organizationId))!;
+    return { template, organization, documents };
+}
+
+describe('DocumentRenderService', () => {
+    describe('buildDocumentContext', () => {
+        test('The platform logo falls back from logoDocuments to horizontalLogo to squareLogo', () => {
+            const logoDocuments = createImage('logo-documents');
+            const horizontalLogo = createImage('horizontal-logo');
+            const squareLogo = createImage('square-logo');
+
+            const organization = createOrganization();
+            const document = createDocument();
+
+            const all = DocumentRenderService.buildDocumentContext(document, organization, createPlatform({ logoDocuments, horizontalLogo, squareLogo }));
+            expect(all['platform'].logo.id).toBe(logoDocuments.id);
+            expect(all['logo'].id).toBe(logoDocuments.id);
+
+            const withoutDocumentsLogo = DocumentRenderService.buildDocumentContext(document, organization, createPlatform({ horizontalLogo, squareLogo }));
+            expect(withoutDocumentsLogo['platform'].logo.id).toBe(horizontalLogo.id);
+            expect(withoutDocumentsLogo['logo'].id).toBe(horizontalLogo.id);
+
+            const onlySquareLogo = DocumentRenderService.buildDocumentContext(document, organization, createPlatform({ squareLogo }));
+            expect(onlySquareLogo['platform'].logo.id).toBe(squareLogo.id);
+            expect(onlySquareLogo['logo'].id).toBe(squareLogo.id);
+        });
+
+        test('No logo is added to the context when the platform and the organization have none', () => {
+            const context = DocumentRenderService.buildDocumentContext(createDocument(), createOrganization(), createPlatform({}));
+
+            expect(context['platform']).toBeUndefined();
+            expect(context['logo']).toBeUndefined();
+            expect(context['organization'].logo).toBeUndefined();
+        });
+
+        test('The organization logo takes precedence over the platform logo', () => {
+            const platformLogo = createImage('logo-documents');
+            const organizationLogo = createImage('organization-horizontal-logo');
+
+            const organization = createOrganization({ horizontalLogo: organizationLogo });
+            const context = DocumentRenderService.buildDocumentContext(createDocument(), organization, createPlatform({ logoDocuments: platformLogo }));
+
+            expect(context['logo'].id).toBe(organizationLogo.id);
+            expect(context['organization'].logo.id).toBe(organizationLogo.id);
+
+            // The platform logo remains available separately
+            expect(context['platform'].logo.id).toBe(platformLogo.id);
+        });
+    });
+
+    describe('getRenderedHtml', () => {
+        test('It returns null and logs when building the context fails', async () => {
+            const template = await new DocumentTemplateFactory({ groups: [] }).create();
+
+            const document = createDocument();
+            document.templateId = template.id;
+            document.organizationId = template.organizationId;
+            document.data.fieldAnswers = createInvalidFieldAnswers();
+
+            const consoleError = vitest.spyOn(console, 'error').mockImplementation(() => {});
+
+            try {
+                await expect(DocumentRenderService.getRenderedHtml(document, createOrganization())).resolves.toBeNull();
+                expect(consoleError).toHaveBeenCalledWith('Failed to render document html', expect.any(Error));
+            } finally {
+                consoleError.mockRestore();
+            }
+        });
+
+        test('It returns null when the template no longer exists', async () => {
+            const document = createDocument();
+            document.templateId = '00000000-0000-4000-8000-000000000000';
+
+            await expect(DocumentRenderService.getRenderedHtml(document, createOrganization())).resolves.toBeNull();
+        });
+    });
+
+    describe('getRenderedXml', () => {
+        test('It renumbers the published documents to be strictly increasing and saves them', async () => {
+            const { template, organization, documents } = await createTemplateWithDocuments([1, 3, 7]);
+
+            const xml = await DocumentRenderService.getRenderedXml(template, organization);
+
+            expect(xml).toBe('<documents><document>1</document><document>2</document><document>3</document></documents>');
+
+            // The gaps are closed in the database too
+            for (const [index, document] of documents.entries()) {
+                const reloaded = await Document.getByID(document.id);
+                expect(reloaded!.number).toBe(index + 1);
+            }
+        });
+
+        test('It rethrows a SimpleError instead of swallowing it', async () => {
+            // A locked document cannot be renumbered: saving it throws a SimpleError
+            const { template, organization } = await createTemplateWithDocuments([2], { lockDocuments: true });
+
+            const error = await DocumentRenderService.getRenderedXml(template, organization).then(() => null, (e: unknown) => e);
+
+            expect(error).toBeInstanceOf(SimpleError);
+            expect((error as SimpleError).code).toBe('locked');
+        });
+
+        test('It returns null and logs for any other error', async () => {
+            const { template, organization } = await createTemplateWithDocuments([1]);
+
+            template.settings.fieldAnswers = createInvalidFieldAnswers();
+
+            const consoleError = vitest.spyOn(console, 'error').mockImplementation(() => {});
+
+            try {
+                await expect(DocumentRenderService.getRenderedXml(template, organization)).resolves.toBeNull();
+                expect(consoleError).toHaveBeenCalledWith('Failed to render document html', expect.any(Error));
+            } finally {
+                consoleError.mockRestore();
+            }
+        });
+
+        test('It returns null without building anything when the template has no xml export', async () => {
+            const { template, organization, documents } = await createTemplateWithDocuments([2], { xmlExport: null });
+
+            await expect(DocumentRenderService.getRenderedXml(template, organization)).resolves.toBeNull();
+
+            // No renumbering happened
+            expect((await Document.getByID(documents[0]!.id))!.number).toBe(2);
+        });
+    });
+});

package/src/services/DocumentRenderService.ts

@@ -0,0 +1,180 @@
+import { isSimpleError, isSimpleErrors } from '@simonbackx/simple-errors';
+import type { Document, Organization } from '@stamhoofd/models';
+import { DocumentTemplate, Platform } from '@stamhoofd/models';
+import { render } from '@stamhoofd/models/helpers/Handlebars.js';
+import type { Platform as PlatformStruct } from '@stamhoofd/structures';
+import { DocumentStatus, Version } from '@stamhoofd/structures';
+import { Sorter } from '@stamhoofd/utility';
+
+/**
+ * Renders documents and document templates into HTML/XML.
+ */
+export class DocumentRenderService {
+    /**
+     * Build the handlebars context of a single document.
+     */
+    static buildDocumentContext(document: Document, organization: Organization, platform: PlatformStruct) {
+        // Convert the field answers in a simplified javascript object
+        const data: Record<string, any> = {
+            id: document.id,
+            name: document.data.name,
+            number: document.number,
+            created_at: document.createdAt,
+            organization: {
+                name: organization.name,
+                companyName: organization.meta.companies[0]?.name || organization.name,
+                companyNumber: organization.meta.companies[0]?.companyNumber || null,
+                address: organization.address,
+                companyAddress: organization.meta.companies[0]?.address ?? organization.address,
+            },
+        };
+        const platformLogo = platform.config.logoDocuments ?? platform.config.horizontalLogo ?? platform.config.squareLogo;
+        const organizationLogo = organization.meta.horizontalLogo ?? organization.meta.squareLogo;
+        const logo = organizationLogo || platformLogo;
+
+        if (organizationLogo) {
+            data['organization'] = {
+                ...data['organization'],
+                logo: organizationLogo.encode({ version: Version }) ?? null,
+            };
+        }
+
+        if (platformLogo) {
+            data['platform'] = {
+                logo: platformLogo.encode({ version: Version }) ?? null,
+            };
+        }
+
+        if (logo) {
+            data['logo'] = logo.encode({ version: Version }) ?? null;
+        }
+
+        for (const field of document.data.fieldAnswers.values()) {
+            const keys = field.settings.id.split('.');
+            let current = data;
+            const lastKey = keys.pop()!;
+            if (!lastKey) {
+                throw new Error('Invalid field id');
+            }
+            for (const key of keys) {
+                if (!current[key]) {
+                    current[key] = {};
+                }
+                current = current[key];
+
+                if (typeof current !== 'object') {
+                    throw new Error('Invalid field type');
+                }
+            }
+            current[lastKey] = field.objectValue;
+        }
+        return data;
+    }
+
+    /**
+     * Build the handlebars context of a whole template.
+     *
+     * Note that this writes: an XML export is the moment the numbering becomes final, so any gaps
+     * left by deleted documents are closed and the new numbers are saved.
+     */
+    private static async buildTemplateContext(template: DocumentTemplate, organization: Organization) {
+        // Convert the field answers in a simplified javascript object
+        const documents = (await template.buildAll({ generateNumbers: true })).filter(d => d.status === DocumentStatus.Published && !!d.number).sort((a, b) => Sorter.byNumberValue(b.number ?? 0, a.number ?? 0));
+
+        // Check numbers are strictly increasing
+        let lastNumber = 0;
+        for (const document of documents) {
+            if (document.number !== lastNumber + 1) {
+                document.number = lastNumber + 1;
+                await document.save();
+            }
+            lastNumber = document.number;
+        }
+
+        const platform = await Platform.getSharedStruct();
+
+        const data: Record<string, any> = {
+            id: template.id,
+            created_at: template.createdAt,
+            documents: documents.map(d => this.buildDocumentContext(d, organization, platform)),
+            organization: {
+                name: organization.name,
+                companyName: organization.meta.companies[0]?.name || organization.name,
+                companyNumber: organization.meta.companies[0]?.companyNumber || null,
+                address: organization.address,
+                companyAddress: organization.meta.companies[0]?.address ?? organization.address,
+            },
+        };
+
+        for (const field of template.settings.fieldAnswers.values()) {
+            const keys = field.settings.id.split('.');
+            let current = data;
+            const lastKey = keys.pop()!;
+            if (!lastKey) {
+                throw new Error('Invalid field id');
+            }
+            for (const key of keys) {
+                if (!current[key]) {
+                    current[key] = {};
+                }
+                current = current[key];
+
+                if (typeof current !== 'object') {
+                    throw new Error('Invalid field type');
+                }
+            }
+            current[lastKey] = field.objectValue;
+        }
+
+        return data;
+    }
+
+    /**
+     * Render a document with the html of the template it belongs to.
+     */
+    static async getRenderedHtml(document: Document, organization: Organization): Promise<string | null> {
+        const template = await DocumentTemplate.getByID(document.templateId);
+        if (!template) {
+            return null;
+        }
+
+        return await this.getRenderedHtmlForTemplate(document, organization, template.html);
+    }
+
+    private static async getRenderedHtmlForTemplate(document: Document, organization: Organization, htmlTemplate: string): Promise<string | null> {
+        try {
+            const platform = await Platform.getSharedStruct();
+            const context = this.buildDocumentContext(document, organization, platform);
+            const renderedHtml = await render(htmlTemplate, context);
+            return renderedHtml;
+        } catch (e) {
+            console.error('Failed to render document html', e);
+            return null;
+        }
+    }
+
+    /**
+     * Render the XML export of a template, containing all its published documents.
+     *
+     * Unlike getRenderedHtml this rethrows SimpleErrors: building the context finalises the document
+     * numbering, and a failure there (a locked document for example) has to reach the user instead of
+     * silently turning into a missing export.
+     */
+    static async getRenderedXml(template: DocumentTemplate, organization: Organization): Promise<string | null> {
+        if (!template.privateSettings.templateDefinition.xmlExport) {
+            return null;
+        }
+
+        try {
+            const context = await this.buildTemplateContext(template, organization);
+            const renderedHtml = await render(template.privateSettings.templateDefinition.xmlExport, context);
+            return renderedHtml;
+        } catch (e) {
+            if (isSimpleError(e) || isSimpleErrors(e)) {
+                throw e;
+            }
+            console.error('Failed to render document html', e);
+            return null;
+        }
+    }
+}