@stamhoofd/models 2.120.6 → 2.121.0

package/src/helpers/InvoiceCounter.test.ts

@@ -0,0 +1,220 @@
+import { describe, it, expect } from 'vitest';
+import { InvoiceCounter } from './InvoiceCounter.js';
+import { OrganizationInvoiceSettings } from '@stamhoofd/structures/OrganizationInvoiceSettings.js';
+import { Invoice } from '../models/Invoice.js';
+import { OrganizationFactory } from '../factories/OrganizationFactory.js';
+
+// Minimal settings factory
+function makeSettings(overrides: Partial<OrganizationInvoiceSettings> = {}): OrganizationInvoiceSettings {
+    return OrganizationInvoiceSettings.create({
+        resetMonth: null,
+        prefixYear: false,
+        ...overrides,
+    })
+}
+
+// ─────────────────────────────────────────────
+// parseNumber
+// ─────────────────────────────────────────────
+describe('InvoiceCounter.parseNumber', () => {
+    describe('without year prefix', () => {
+        const settings = makeSettings({ prefixYear: false });
+
+        it('parses ABC-123 → 123', () => {
+            expect(InvoiceCounter.parseNumber(settings, 'ABC-123')).toBe(123);
+        });
+
+        it('parses XXX0001 → 1', () => {
+            expect(InvoiceCounter.parseNumber(settings, 'XXX0001')).toBe(1);
+        });
+
+        it('parses 05STA0001 → 1', () => {
+            expect(InvoiceCounter.parseNumber(settings, '05STA0001')).toBe(1);
+        });
+
+        it('parses 1234-0011 → 11', () => {
+            expect(InvoiceCounter.parseNumber(settings, '1234-0011')).toBe(11);
+        });
+    });
+
+    describe('with year prefix (prefixYear: true)', () => {
+        const settings = makeSettings({ prefixYear: true });
+
+        it('parses 2012001584 → 1584', () => {
+            expect(InvoiceCounter.parseNumber(settings, '2012001584')).toBe(1584);
+        });
+
+        it('parses XXX-2012001584 → 1584', () => {
+            expect(InvoiceCounter.parseNumber(settings, 'XXX-2012001584')).toBe(1584);
+        });
+    });
+});
+
+describe('InvoiceCounter.formatNumber', () => {
+    const date2025 = new Date('2025-06-15T12:00:00Z');
+
+    it('formats 123 with fixed prefix ABC → "ABC000123"', () => {
+        const settings = makeSettings({ fixedPrefix: 'ABC' });
+        expect(InvoiceCounter.formatNumber(settings, 123, date2025)).toBe('ABC000123');
+    });
+
+    it('formats 123 with fixed prefix ABC1 → "ABC1-000123"', () => {
+        const settings = makeSettings({ fixedPrefix: 'ABC1' });
+        expect(InvoiceCounter.formatNumber(settings, 123, date2025)).toBe('ABC1-000123');
+    });
+
+    it('formats 1 with year prefix → "2025000001"', () => {
+        const settings = makeSettings({ prefixYear: true });
+        expect(InvoiceCounter.formatNumber(settings, 1, date2025)).toBe('2025000001');
+    });
+
+    it('formats 11 with fixed prefix "111-" and no duplicate dash → "111-000011"', () => {
+        const settings = makeSettings({ fixedPrefix: '111-' });
+        expect(InvoiceCounter.formatNumber(settings, 11, date2025)).toBe('111-000011');
+    });
+
+    it('formats 11 with fixed prefix "test-" and no duplicate dash → "test-000011"', () => {
+        const settings = makeSettings({ fixedPrefix: 'test-' });
+        expect(InvoiceCounter.formatNumber(settings, 11, date2025)).toBe('test-000011');
+    });
+
+    it('formats 54 with year prefix + fixed prefix → "ABC202500054"', () => {
+        // year is prepended first, then fixedPrefix wraps around
+        const settings = makeSettings({ prefixYear: true, fixedPrefix: 'ABC' });
+        expect(InvoiceCounter.formatNumber(settings, 54, date2025)).toBe('ABC2025000054');
+    });
+});
+
+describe('InvoiceCounter.shouldStartNewSeries', () => {
+    it('returns false when resetMonth is null', () => {
+        const settings = makeSettings({ resetMonth: null });
+        const last = new Date('2024-12-01');
+        const now = new Date('2025-06-01');
+        expect(InvoiceCounter.shouldStartNewSeries(settings, last, now)).toBe(false);
+    });
+
+    it('returns true when crossing the reset month boundary', () => {
+        // reset on January (month 1)
+        const settings = makeSettings({ resetMonth: 1 });
+        const last = new Date('2024-06-15');
+        const now = new Date('2025-01-02');
+        expect(InvoiceCounter.shouldStartNewSeries(settings, last, now)).toBe(true);
+    });
+
+    it('returns false when still within the same series period', () => {
+        const settings = makeSettings({ resetMonth: 1 });
+        const last = new Date('2025-01-05');
+        const now = new Date('2025-06-01');
+        expect(InvoiceCounter.shouldStartNewSeries(settings, last, now)).toBe(false);
+    });
+});
+
+describe('InvoiceCounter.assignNextNumber', () => {
+    beforeEach(() => {
+        InvoiceCounter.clearAll();
+        vitest.useFakeTimers({ toFake: ['Date'] });
+    });
+
+    afterEach(() => {
+        vitest.useRealTimers();
+    });
+
+    it('assigns 000001 to the first invoice for an org (no cache, no DB)', async () => {
+        const org = await new OrganizationFactory({}).create();
+        const settings = makeSettings({});
+
+        const invoice = new Invoice();
+        invoice.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice, settings);
+
+        expect(invoice.number).toBe('000001');
+        expect(invoice.invoicedAt).not.toBeNull();
+    });
+
+    it('increments from cache when called twice without a reset boundary', async () => {
+        const org = await new OrganizationFactory({}).create();
+        const settings = makeSettings({});
+
+        const invoice1 = new Invoice();
+        invoice1.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice1, settings);
+        expect(invoice1.number).toBe('000001');
+
+        const invoice2 = new Invoice();
+        invoice2.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice2, settings);
+        expect(invoice2.number).toBe('000002');
+    });
+
+    it('continues from DB when cache is absent but a numbered invoice exists', async () => {
+        const org = await new OrganizationFactory({}).create();
+        const settings = makeSettings({});
+
+        const existing = new Invoice();
+        existing.organizationId = org.id;
+        existing.number = '000042';
+        existing.invoicedAt = new Date();
+        await existing.save();
+
+        InvoiceCounter.clearAll();
+
+        const invoice = new Invoice();
+        invoice.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice, settings);
+
+        expect(invoice.number).toBe('000043');
+    });
+
+    it('starts a new series when the reset boundary is crossed (cache hit)', async () => {
+        const org = await new OrganizationFactory({}).create();
+        const settings = makeSettings({ resetMonth: 1, prefixYear: true });
+
+        vitest.setSystemTime(new Date('2024-06-15T12:00:00Z'));
+        const invoice1 = new Invoice();
+        invoice1.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice1, settings);
+        expect(invoice1.number).toBe('2024000001');
+
+        // Advance past the January 2025 reset boundary
+        vitest.setSystemTime(new Date('2025-02-01T12:00:00Z'));
+        const invoice2 = new Invoice();
+        invoice2.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice2, settings);
+
+        expect(invoice2.number).toBe('2025000001');
+    });
+
+    it('falls back to 1 when the DB invoice number cannot be parsed', async () => {
+        const org = await new OrganizationFactory({}).create();
+        const settings = makeSettings({});
+
+        const existing = new Invoice();
+        existing.organizationId = org.id;
+        existing.number = 'INVALID';
+        existing.invoicedAt = new Date();
+        await existing.save();
+
+        const invoice = new Invoice();
+        invoice.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice, settings);
+
+        expect(invoice.number).toBe('000001');
+    });
+
+    it('reads from DB after resetNumbers clears the cache', async () => {
+        const org = await new OrganizationFactory({}).create();
+        const settings = makeSettings({});
+
+        const invoice1 = new Invoice();
+        invoice1.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice1, settings);
+        expect(invoice1.number).toBe('000001');
+
+        await InvoiceCounter.resetNumbers(org.id);
+
+        const invoice2 = new Invoice();
+        invoice2.organizationId = org.id;
+        await InvoiceCounter.assignNextNumber(invoice2, settings);
+        expect(invoice2.number).toBe('000002');
+    });
+});

package/src/helpers/InvoiceCounter.ts

@@ -0,0 +1,162 @@
+import { QueueHandler } from '@stamhoofd/queues';
+
+import type { OrganizationInvoiceSettings } from '@stamhoofd/structures/OrganizationInvoiceSettings.js';
+import { Formatter } from '@stamhoofd/utility';
+import type { DateTime } from 'luxon';
+import { Invoice } from '../models/Invoice.js';
+
+export class InvoiceCounter {
+    static numberCache: Map<string, {lastNumber: number, date: Date}> = new Map();
+
+
+    private static getNextResetDate(last: DateTime, resetMonth: number): DateTime {
+        const candidate = last.set({ month: resetMonth, day: 1 }).startOf('day');
+        return candidate > last ? candidate : candidate.plus({ years: 1 }).startOf('day');
+    }
+
+    static shouldStartNewSeries(settings: OrganizationInvoiceSettings, lastInvoiceDate: Date, invoiceDate: Date) {
+        if (settings.resetMonth === null) {
+            return false;
+        }
+
+        const last = Formatter.luxon(lastInvoiceDate);
+        const current = Formatter.luxon(invoiceDate);
+
+        return current >= this.getNextResetDate(last, settings.resetMonth)
+    }
+
+    /**
+     * XXX-123 -> 123
+     * YYY-0001 -> 1
+     * 
+     * if prefix is enabled:
+     * 2025001 -> 1
+     * STA-2025001 -> 1
+     */
+    static parseNumber(settings: OrganizationInvoiceSettings, str: string) {
+        str = str.replace(/\D+/g, '-').replace(/^-+/, '').replace(/-+$/, '');
+        // Remove prefixes and possibly year
+        const splitted = str.split('-');
+
+        let last = splitted[splitted.length - 1];
+
+        const stripYear = settings.prefixYear
+
+        if (last.length) {
+            if (stripYear) {
+                if (last.length <= 4) {
+                    console.error('Could not parse invoice number from string ' + str + ' (could not trim year prefix)')
+                    return null;
+                }
+                last = last.substring(4)
+            }
+
+            const int = parseInt(last);
+            if (int !== 0 && !isNaN(int) && isFinite(int)) {
+                return int;
+            }
+        }
+
+        console.error('Could not parse invoice number from string ' + str)
+        return null;
+    }
+
+    static formatNumber(settings: OrganizationInvoiceSettings, int: number, invoicedAt: Date) {
+        let str = int.toFixed(0).padStart(settings.padZeroLength, '0')
+
+        if (settings.prefixYear) {
+            const year = Formatter.luxon(invoicedAt).year
+            str = year + str;
+        }
+
+        if (settings.fixedPrefix) {
+            if (!settings.fixedPrefix.match(/\D$/)) {
+                // Need seperation character
+                str = settings.fixedPrefix.replace(/-$/, '') + '-' + str;
+            } else {
+                str = settings.fixedPrefix +  str;
+            }
+        }
+
+        return str;
+    }
+
+    static async assignNextNumber(invoice: Invoice, settings: OrganizationInvoiceSettings): Promise<void> {
+        const organizationId = invoice.organizationId
+        return await QueueHandler.schedule('invoice/numbers-' + organizationId, async () => {
+            // Invoice date should be inside the queue to ensure it is chronologically generated
+            const invoicedAt = new Date();
+
+            const c = this.numberCache.get(organizationId);
+            if (c !== undefined) {
+                const lastNumber = c.lastNumber
+
+                // check date
+                if (!this.shouldStartNewSeries(settings, c.date, invoicedAt)) {
+                    // Set and save.
+                    // we do this here because it assures we'll not increase the next number if the save fails
+                    invoice.number = this.formatNumber(settings, lastNumber + 1, invoicedAt);
+                    invoice.invoicedAt = invoicedAt;
+                    await invoice.save()
+
+                    // If save succeeds, increase cache:
+                    this.numberCache.set(organizationId, {
+                        lastNumber: lastNumber + 1,
+                        date: new Date(invoicedAt)
+                    });
+                    return
+                }
+            }
+
+            const lastInvoice = await Invoice.select()
+                    .where('organizationId', organizationId)
+                    .where('number', '!=', null)
+                    .where('invoicedAt', '!=', null)
+                    .orderBy('invoicedAt', 'DESC')
+                    .first(false);
+
+            if (lastInvoice && lastInvoice.number && lastInvoice.invoicedAt) {
+                // check date
+                if (!this.shouldStartNewSeries(settings, lastInvoice.invoicedAt, invoicedAt)) {
+                    const lastNumber = this.parseNumber(settings, lastInvoice.number)
+
+                    if (lastNumber) {
+                        invoice.number = this.formatNumber(settings, lastNumber + 1, invoicedAt);
+                        invoice.invoicedAt = invoicedAt;
+                        await invoice.save()
+                        
+                        this.numberCache.set(organizationId, {
+                            lastNumber: lastNumber + 1,
+                            date: new Date(invoicedAt)
+                        });
+                        return;
+                    }
+                }
+            }
+
+            // Start new
+            invoice.number = this.formatNumber(settings, 1, invoicedAt);
+            invoice.invoicedAt = invoicedAt;
+            await invoice.save()
+            
+            this.numberCache.set(organizationId, {
+                lastNumber: 1,
+                date: new Date(invoicedAt)
+            });
+            return;
+        });
+    }
+
+    static async resetNumbers(organizationId: string): Promise<void> {
+        // Prevent race conditions: create a queue
+        // The queue can only run one at a time for the same webshop (so multiple webshops at the same time are allowed)
+        return await QueueHandler.schedule('invoice/numbers-' + organizationId, async () => {
+            this.numberCache.delete(organizationId);
+            return Promise.resolve();
+        });
+    }
+
+    static clearAll() {
+        this.numberCache.clear();
+    }
+}

package/src/migrations/1763216320-bigint-balance-item-payments.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `balance_item_payments`
+CHANGE `price` `price` bigint NOT NULL DEFAULT '0';

package/src/migrations/1763216320-bigint-balance-items.sql

@@ -0,0 +1,5 @@
+ALTER TABLE `balance_items`
+CHANGE `unitPrice` `unitPrice` bigint NOT NULL DEFAULT '0',
+CHANGE `pricePaid` `pricePaid` bigint NOT NULL DEFAULT '0',
+CHANGE `pricePending` `pricePending` bigint NOT NULL DEFAULT '0',
+CHANGE `priceOpen` `priceOpen` bigint NOT NULL DEFAULT '0';

package/src/migrations/1763216320-bigint-orders.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `webshop_orders`
+CHANGE `totalPrice` `totalPrice` bigint NULL;

package/src/migrations/1763216320-bigint-payments.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `payments`
+CHANGE `price` `price` bigint NOT NULL DEFAULT '0';

package/src/migrations/1763216332-bigint-balance-item-price-total.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `balance_items`
+CHANGE `priceTotal` `priceTotal` bigint NOT NULL DEFAULT '0';

package/src/migrations/1776873089-create-registration-invitations-table.sql

@@ -0,0 +1,13 @@
+CREATE TABLE `registration_invitations` (
+	`id` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
+	`memberId` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
+	`groupId` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
+	`organizationId` varchar(36) CHARACTER SET utf8mb4 COLLATE utf8mb4_0900_ai_ci NOT NULL,
+	`createdAt` datetime NOT NULL,
+	PRIMARY KEY (`id`),
+    UNIQUE KEY `uk_member_group` (`memberId`, `groupId`),
+    KEY `idx_memberId` (`memberId`) USING BTREE,
+	CONSTRAINT `registration_invitations_ibfk_1` FOREIGN KEY (`memberId`) REFERENCES `members` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
+	CONSTRAINT `registration_invitations_ibfk_2` FOREIGN KEY (`groupId`) REFERENCES `groups` (`id`) ON DELETE CASCADE ON UPDATE CASCADE,
+    CONSTRAINT `registration_invitations_ibfk_3` FOREIGN KEY (`organizationId`) REFERENCES `organizations` (`id`) ON UPDATE CASCADE ON DELETE CASCADE
+) ENGINE = InnoDB DEFAULT CHARSET = utf8mb4 COLLATE = utf8mb4_unicode_ci;

package/src/migrations/1778657958-payments-create-mandate.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `payments`
+ADD COLUMN `createMandate` json NULL AFTER `stripeAccountId`;

package/src/migrations/1778657959-payments-mandate-id.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `payments`
+ADD COLUMN `mandateId` varchar(36) NULL AFTER `stripeAccountId`;

package/src/migrations/1778796615-payments-reversing-payment-id.sql

@@ -0,0 +1,3 @@
+ALTER TABLE `payments`
+ADD COLUMN `reversingPaymentId` varchar(36) NULL AFTER `invoiceId`,
+ADD FOREIGN KEY (`reversingPaymentId`) REFERENCES `payments` (`id`) ON UPDATE CASCADE ON DELETE SET NULL;

package/src/migrations/1778950642-price-invoiced.sql

@@ -0,0 +1,2 @@
+ALTER TABLE `balance_items`
+ADD COLUMN `priceInvoiced` int NOT NULL DEFAULT '0' AFTER `priceOpen`;

package/src/models/BalanceItem.ts

@@ -186,6 +186,12 @@ export class BalanceItem extends QueryableModel {
     })
     priceOpen = 0;
 
+    /**
+     * Cached value, for optimizations
+     */
+    @column({ type: 'integer' })
+    priceInvoiced = 0;
+
     /**
      * todo: deprecate ('pending' and 'paid') + 'hidden' status and replace with 'due' + 'hidden'
      * -> maybe add 'due' (due if dueAt is null or <= now), 'hidden' (never due), 'future' (= not due until dueAt - but not possible to pay earlier)
@@ -544,6 +550,49 @@ export class BalanceItem extends QueryableModel {
         await Database.update(query, params);
     }
 
+        /**
+     * Update the outstanding balance of multiple members in one go (or all members)
+     */
+    static async updateInvoiced(balanceItemIds: string[] | 'all') {
+        if (balanceItemIds !== 'all' && balanceItemIds.length === 0) {
+            return 0;
+        }
+
+        const params: any[] = [];
+        let firstWhere = '';
+        let secondWhere = '';
+
+        if (balanceItemIds !== 'all') {
+            firstWhere = ` AND balanceItemId IN (?)`;
+            params.push(balanceItemIds);
+            params.push(balanceItemIds);
+
+            secondWhere = `WHERE balance_items.id IN (?)`;
+            params.push(balanceItemIds);
+        }
+
+        // Note: this query only works in MySQL because of the SET assignment behaviour allowing to reference newly set values
+        const query = `
+        UPDATE
+            balance_items
+        LEFT JOIN (
+            SELECT
+                balanceItemId,
+                sum(invoiced_balance_items.balanceInvoicedAmount) AS invoiced
+            FROM
+                invoiced_balance_items
+                LEFT JOIN invoices ON invoices.id = invoiced_balance_items.invoiceId
+            WHERE
+                invoices.number is not null${firstWhere}
+            GROUP BY
+                balanceItemId
+            ) invoiced ON invoiced.balanceItemId = balance_items.id
+        SET balance_items.priceInvoiced = coalesce(invoiced.invoiced, 0)
+        ${secondWhere}`;
+
+        return (await Database.update(query, params))[0].affectedRows;
+    }
+
     static async loadPayments(items: (BalanceItem | { id: string })[]) {
         if (items.length == 0) {
             return { balanceItemPayments: [], payments: [] };
@@ -664,10 +713,15 @@ export class BalanceItem extends QueryableModel {
         return balanceItems;
     }
 
-    static async balanceItemsForOrganization(organizationId: string): Promise<BalanceItem[]> {
-        return await BalanceItem.select()
-            .where('payingOrganizationId', organizationId)
-            .whereNot('status', BalanceItemStatus.Hidden)
-            .fetch();
+    static async balanceItemsForOrganization(payingOrganizationId: string, organizationId?: string): Promise<BalanceItem[]> {
+        const base = BalanceItem.select()
+            .where('payingOrganizationId', payingOrganizationId)
+            .whereNot('status', BalanceItemStatus.Hidden);
+
+        if (organizationId) {
+            base.where('organizationId', organizationId)
+        }
+
+        return await base.fetch();
     }
 }

package/src/models/Group.ts

@@ -1,12 +1,12 @@
-import { column, Database, ManyToOneRelation } from '@simonbackx/simple-database';
-import type { GroupCategory} from '@stamhoofd/structures';
+import { column, Database } from '@simonbackx/simple-database';
+import type { GroupCategory } from '@stamhoofd/structures';
 import { GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType, StockReservation } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 
 import { ArrayDecoder } from '@simonbackx/simple-encoding';
 import { QueueHandler } from '@stamhoofd/queues';
 import { QueryableModel } from '@stamhoofd/sql';
-import type {OrganizationRegistrationPeriod} from './OrganizationRegistrationPeriod.js';
+import type { OrganizationRegistrationPeriod } from './OrganizationRegistrationPeriod.js';
 import { Registration } from './Registration.js';
 
 if (Registration === undefined) {
@@ -90,6 +90,27 @@ export class Group extends QueryableModel {
     @column({ type: 'json', decoder: new ArrayDecoder(StockReservation) })
     stockReservations: StockReservation[] = [];
 
+    /**
+     * No registrations and waiting list registrations are possible if closed
+     */
+    get closed() {
+        if (this.status !== GroupStatus.Open) {
+            return true;
+        }
+
+        if (this.settings.notYetOpen) {
+            // Start date or pre registration date are in the future
+            return true;
+        }
+
+        const now = new Date();
+        if (this.settings.registrationEndDate && this.settings.registrationEndDate < now) {
+            return true;
+        }
+
+        return false;
+    }
+
     static async getAll(organizationId: string, periodId: string | null, active = true, types: GroupType[] = [GroupType.Membership]): Promise<Group[]> {
         const query = Group.select()
             .where('organizationId', organizationId);

package/src/models/Invoice.ts

@@ -1,5 +1,5 @@
 import { column } from '@simonbackx/simple-database';
-import { Company, File, Invoice as InvoiceStruct, PaymentCustomer, VATSubtotal } from '@stamhoofd/structures';
+import { Company, File, PaymentCustomer, VATSubtotal } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 
 import { ArrayDecoder } from '@simonbackx/simple-encoding';
@@ -109,14 +109,6 @@ export class Invoice extends QueryableModel {
     @column({
         type: 'datetime',
         nullable: true,
-        beforeSave(old?: any) {
-            if (old !== undefined || !this.number) {
-                return old;
-            }
-            const date = new Date();
-            date.setMilliseconds(0);
-            return date;
-        },
     })
     invoicedAt: Date | null = null;