@stamhoofd/backend 2.120.6 → 2.122.0

package/src/helpers/StripeHelper.ts

@@ -1,8 +1,8 @@
 import { SimpleError } from '@simonbackx/simple-errors';
 import type { I18n } from '@stamhoofd/backend-i18n';
-import type { BalanceItem, BalanceItemPayment, Organization, StripeAccount} from '@stamhoofd/models';
+import type { Organization, StripeAccount } from '@stamhoofd/models';
 import { Payment, StripeCheckoutSession, StripePaymentIntent } from '@stamhoofd/models';
-import { calculateVATPercentage, PaymentMethod, PaymentMethodHelper, PaymentStatus } from '@stamhoofd/structures';
+import { PaymentMethod, PaymentMethodHelper, PaymentStatus } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import Stripe from 'stripe';
 import { passthroughFetch } from './passthroughFetch.js';
@@ -68,15 +68,13 @@ export class StripeHelper {
                 if (charge.payment_method_details.sepa_debit.last4) {
                     if (charge.payment_method_details.sepa_debit.country === 'BE') {
                         payment.iban = charge.payment_method_details.sepa_debit.country + '•• ' + charge.payment_method_details.sepa_debit.bank_code + '• •••• ' + charge.payment_method_details.sepa_debit.last4;
-                    }
-                    else {
+                    } else {
                         payment.iban = '•••• ' + charge.payment_method_details.sepa_debit.last4;
                     }
                 }
             }
             await payment.save();
-        }
-        catch (e) {
+        } catch (e) {
             console.error('Failed processing charge', e);
         }
     }
@@ -145,8 +143,7 @@ export class StripeHelper {
                 if (intent.status === 'canceled' || intent.status === 'requires_payment_method') {
                     return PaymentStatus.Failed;
                 }
-            }
-            catch (e) {
+            } catch (e) {
                 console.error('Error cancelling payment intent', e);
             }
         }
@@ -161,6 +158,10 @@ export class StripeHelper {
         const [model] = await StripeCheckoutSession.where({ paymentId: payment.id }, { limit: 1 });
 
         if (!model) {
+            if (payment.createdAt.getTime() > Date.now() - 1000 * 10) {
+                // Possibly missing model data because the payment has only been created just yet
+                return payment.status;
+            }
             return PaymentStatus.Failed;
         }
 
@@ -207,7 +208,7 @@ export class StripeHelper {
     }
 
     static async createPayment(
-        { payment, stripeAccount, redirectUrl, cancelUrl, customer, statementDescriptor, i18n, metadata, organization, lineItems }: {
+        { payment, stripeAccount, redirectUrl, cancelUrl, customer, statementDescriptor, i18n, metadata, organization }: {
             payment: Payment;
             stripeAccount: StripeAccount | null;
             redirectUrl: string;
@@ -218,9 +219,8 @@ export class StripeHelper {
             };
             statementDescriptor: string;
             i18n: I18n;
-            metadata: { [key: string]: string };
+            metadata: { [key: string]: string | undefined };
             organization: Organization;
-            lineItems: (BalanceItemPayment & { balanceItem: BalanceItem })[];
         },
     ): Promise<{ paymentUrl: string }> {
         if (!stripeAccount) {
@@ -240,36 +240,14 @@ export class StripeHelper {
             });
         }
 
-        let fee = 0;
-        let directCharge = false;
-        const vat = calculateVATPercentage(organization.address, organization.meta.VATNumber);
-        function calculateFee(fixed: number, percentageTimes100: number) {
-            return Math.round(Math.round(fixed + Math.max(1, totalPrice * percentageTimes100 / 100 / 100)) * (100 + vat) / 100); // € 0,21 + 0,2%
-        }
-
-        if (payment.method === PaymentMethod.iDEAL) {
-            fee = calculateFee(21, 20); // € 0,21 + 0,2%
-        }
-        else if (payment.method === PaymentMethod.Bancontact) {
-            fee = calculateFee(24, 20); // € 0,24 + 0,2%
-        }
-        else {
-            fee = calculateFee(25, 150); // € 0,25 + 1,5%
-        }
-
-        if (stripeAccount.meta.type === 'standard') {
-            // Submerchant is charged by Stripe for the fees directly
-            fee = 0;
-            directCharge = true;
-        }
-
-        payment.transferFee = fee * 100; // Convert back to 4 decimal places for storage
+        const directCharge = (stripeAccount.meta.type === 'standard');
+        const fee = directCharge ? 0 : Math.round(payment.transferFee / 100);
         const serviceFee = Math.round(payment.serviceFeePayout / 100);
 
         const fullMetadata = {
             ...(metadata ?? {}),
             organizationVATNumber: organization.meta.VATNumber,
-            transactionFee: fee,
+            transferFee: fee,
             serviceFee: serviceFee, // For historic reasons, this is stored in cents
         };
 
@@ -336,8 +314,7 @@ export class StripeHelper {
                 paymentIntentModel.accountId = stripeAccount.accountId;
             }
             await paymentIntentModel.save();
-        }
-        else {
+        } else {
             // Use checkout flow
             const data: Stripe.Checkout.SessionCreateParams = {
                 mode: 'payment',

package/src/helpers/StripeInvoicer.ts

@@ -0,0 +1,419 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Email } from '@stamhoofd/email';
+import { BalanceItem, BalanceItemPayment, Invoice, Organization, Payment, StripeAccount, User } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { BalanceItemRelation, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, getPaymentProviderName, InvoiceStruct, PaymentCustomer, PaymentMethod, PaymentProvider, PaymentStatus, PaymentType, TranslatedString } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import Stripe from 'stripe';
+import { InvoiceService } from '../services/InvoiceService.js';
+import { PaymentService } from '../services/PaymentService.js';
+import { AuthenticatedStructures } from './AuthenticatedStructures.js';
+import { VATService } from '../services/VATService.js';
+
+export class ApplicationFeeDetails {
+    transferFee = 0;
+    serviceFee = 0;
+    count = 0;
+    minimumDate: Date | null = null;
+    maximumDate: Date | null = null;
+
+    constructor(details: { count?: number; transferFee: number; serviceFee: number; minimumDate: Date | null; maximumDate: Date | null }) {
+        this.count = details.count ?? 0;
+        this.transferFee = details.transferFee;
+        this.serviceFee = details.serviceFee;
+        this.minimumDate = details.minimumDate;
+        this.maximumDate = details.maximumDate;
+    }
+
+    get amount() {
+        return this.transferFee + this.serviceFee;
+    }
+
+    static fromStripe(transaction: Stripe.BalanceTransaction) {
+        const source = transaction.source as Stripe.ApplicationFee;
+        const metadata = (source.originating_transaction as Stripe.Charge).metadata;
+
+        const serviceFeeStr = metadata.serviceFee as unknown;
+        if (serviceFeeStr === undefined || typeof serviceFeeStr !== 'string') {
+            throw new Error('Missing serviceFee metadata');
+        }
+
+        const parsed = parseInt(serviceFeeStr);
+        if (isNaN(parsed) || !isFinite(parsed)) {
+            throw new Error('Invalid serviceFee metadata');
+        }
+        const serviceFee = parsed * 100; // in cents
+        const transferFee = transaction.amount * 100 - serviceFee;
+
+        return new ApplicationFeeDetails({
+            count: 1,
+            serviceFee,
+            transferFee,
+            minimumDate: new Date(transaction.created * 1000),
+            maximumDate: new Date(transaction.created * 1000),
+        });
+    }
+
+    add(fee: Stripe.BalanceTransaction) {
+        this.combine(ApplicationFeeDetails.fromStripe(fee));
+    }
+
+    remove(fee: Stripe.BalanceTransaction) {
+        this.combine(ApplicationFeeDetails.fromStripe(fee));
+    }
+
+    combine(other: ApplicationFeeDetails) {
+        this.serviceFee += other.serviceFee;
+        this.transferFee += other.transferFee;
+        this.count += other.count;
+        if (other.minimumDate && (this.minimumDate === null || other.minimumDate < this.minimumDate)) {
+            this.minimumDate = other.minimumDate;
+        }
+        if (other.maximumDate && (this.maximumDate === null || other.maximumDate > this.maximumDate)) {
+            this.maximumDate = other.maximumDate;
+        }
+    }
+}
+
+class StripeReport {
+    readonly applicationFeesPerAccount = new Map<string, ApplicationFeeDetails>();
+
+    add(balanceTransaction: Stripe.BalanceTransaction) {
+        if (balanceTransaction.type === 'application_fee' || balanceTransaction.type === 'application_fee_refund') {
+            const source = balanceTransaction.source as Stripe.ApplicationFee;
+            const account = typeof source.account === 'string' ? source.account : source.account.id;
+
+            if (account) {
+                // We don't included refunded fees because these are test payments from test account
+                const currentAmount = this.applicationFeesPerAccount.get(account);
+                if (currentAmount === undefined) {
+                    this.applicationFeesPerAccount.set(account, ApplicationFeeDetails.fromStripe(balanceTransaction));
+                } else {
+                    currentAmount.add(balanceTransaction);
+                }
+            }
+        }
+    }
+
+    combine(report: StripeReport) {
+        for (const [account, amount] of report.applicationFeesPerAccount.entries()) {
+            const currentAmount = this.applicationFeesPerAccount.get(account);
+            if (currentAmount === undefined) {
+                this.applicationFeesPerAccount.set(account, amount);
+            } else {
+                currentAmount.combine(amount);
+            }
+        }
+        return this;
+    }
+}
+
+export class StripeReportInvoicer {
+    private readonly report: StripeReport;
+    start: Date;
+    end: Date;
+
+    constructor(report: StripeReport, start: Date, end: Date) {
+        this.report = report;
+        this.start = start;
+        this.end = end;
+    }
+
+    async generateInvoices(sellingOrganization: Organization, reference: string) {
+        const invoices: Invoice[] = [];
+        for (const [account, details] of this.report.applicationFeesPerAccount) {
+            try {
+                const invoice = await this.generateInvoice(sellingOrganization, reference, account, details);
+                if (invoice) {
+                    invoices.push(invoice);
+                }
+            } catch (e) {
+                console.error(e);
+                // Send email notification of this error
+                Email.sendWebmaster({
+                    subject: 'Aanmaken Stripe facturen voor ' + account + ' - ' + reference + ' mislukt',
+                    html: 'Aanmaken Stripe facturen voor ' + account + ' - ' + reference + ' mislukt. <br><br> ' + e.toString(),
+                });
+            }
+        }
+        return invoices;
+    }
+
+    static async hasInvoice(sellingOrganization: Organization, reference: string) {
+        return !!await Invoice.select().where('organizationId', sellingOrganization.id).where('reference', reference).where('number', '!=', null).first(false);
+    }
+
+    async generateInvoice(sellingOrganization: Organization, reference: string, accountId: string, applicationFee: ApplicationFeeDetails) {
+        if (applicationFee.amount === 0) {
+            return;
+        }
+
+        const seller = sellingOrganization.meta.companies[0];
+        if (!seller) {
+            return;
+        }
+
+        // Search for the organization in Stamhoofd
+        const stripeAccount = await StripeAccount.select().where('accountId', accountId).first(false);
+        if (!stripeAccount) {
+            if (STAMHOOFD.environment === 'test') {
+                console.error('No organization found for Stripe account ' + accountId);
+                return;
+            }
+            throw new SimpleError({
+                code: 'stripe_account_not_found',
+                message: 'No organization found for Stripe account ' + accountId,
+            });
+        }
+        const organization = await Organization.getByID(stripeAccount.organizationId);
+
+        if (!organization) {
+            throw new SimpleError({
+                code: 'organization_not_found',
+                message: 'No organization found for Stripe account ' + accountId,
+            });
+        }
+
+        const existingInvoices = await Invoice.select()
+            .where('organizationId', sellingOrganization.id)
+            .where('payingOrganizationId', organization.id)
+            .where('reference', reference)
+            .where('number', '!=', null)
+            .fetch();
+
+        for (const i of existingInvoices) {
+            if (!i.stripeAccountId && i.totalWithVAT === applicationFee.amount) {
+                i.stripeAccountId = accountId;
+
+                console.log('Set stripe account id for invoice ' + i.number + ' to ' + accountId);
+                await i.save();
+            }
+
+            if (!i.stripeAccountId) {
+                throw new SimpleError({
+                    code: 'invoice_already_exists_with_different_amount',
+                    message: 'Invoice without account id already exists with different amount ' + organization.id + ' expected ' + applicationFee.amount + ' got ' + i.totalWithVAT + ' in invoice ' + i.number,
+                });
+            }
+
+            if (i.stripeAccountId === accountId) {
+                if (i.totalWithVAT !== applicationFee.amount) {
+                    throw new SimpleError({
+                        code: 'invoice_already_exists_with_different_amount',
+                        message: 'Invoice already exists with different amount ' + organization.id + ' expected ' + applicationFee.amount + ' got ' + i.totalWithVAT + ' in invoice ' + i.number,
+                    });
+                }
+
+                // Already invoiced
+                console.warn('Tried to invoice an already invoiced.');
+                return;
+            }
+        }
+
+        const customer = PaymentCustomer.create({
+            company: sellingOrganization.defaultCompanies[0],
+        });
+
+        const balanceItems: BalanceItem[] = [];
+
+        if (applicationFee.serviceFee !== 0) {
+            const item = new BalanceItem();
+            item.type = BalanceItemType.ServiceFee;
+            item.description = $t('%1Wd', {
+                startDate: Formatter.startDate(this.start, false, true),
+                endDate: Formatter.endDate(this.end, false, true),
+            });
+            item.relations.set(BalanceItemRelationType.PaymentProvider, BalanceItemRelation.create({
+                id: PaymentProvider.Stripe,
+                name: TranslatedString.create(getPaymentProviderName(PaymentProvider.Stripe)),
+            }));
+            item.payingOrganizationId = organization.id;
+            item.organizationId = sellingOrganization.id;
+            item.VATPercentage = 21;
+            item.VATExcempt = VATService.getVATExcempt({
+                company: organization.defaultCompanies[0] ?? null,
+                sellingOrganization,
+                type: 'services',
+            });
+            item.VATIncluded = true;
+            item.quantity = 1;
+            item.unitPrice = applicationFee.serviceFee;
+            item.createdAt = new Date();
+            item.status = BalanceItemStatus.Hidden;
+            item.startDate = this.start;
+            item.endDate = this.end;
+            await item.save();
+            balanceItems.push(item);
+        }
+
+        if (applicationFee.transferFee !== 0) {
+            const item = new BalanceItem();
+            item.type = BalanceItemType.TransferFee;
+            item.description = $t('%1Xx', {
+                startDate: Formatter.startDate(this.start, false, true),
+                endDate: Formatter.endDate(this.end, false, true),
+            });
+            item.relations.set(BalanceItemRelationType.PaymentProvider, BalanceItemRelation.create({
+                id: PaymentProvider.Stripe,
+                name: TranslatedString.create(getPaymentProviderName(PaymentProvider.Stripe)),
+            }));
+            item.payingOrganizationId = organization.id;
+            item.organizationId = sellingOrganization.id;
+            item.VATPercentage = 21;
+            item.VATExcempt = VATService.getVATExcempt({
+                company: organization.defaultCompanies[0] ?? null,
+                sellingOrganization,
+                type: 'services',
+            });
+            item.VATIncluded = true;
+            item.quantity = 1;
+            item.unitPrice = applicationFee.transferFee;
+            item.createdAt = new Date();
+            item.status = BalanceItemStatus.Hidden;
+            item.startDate = this.start;
+            item.endDate = this.end;
+            await item.save();
+            balanceItems.push(item);
+        }
+
+        const systemUser = await User.getSystem();
+
+        // Done validation
+        const payment = new Payment();
+        payment.adminUserId = systemUser.id;
+
+        // Who will receive this money?
+        payment.organizationId = sellingOrganization.id;
+
+        // Who paid
+        payment.payingOrganizationId = organization.id;
+        payment.customer = customer;
+
+        payment.status = PaymentStatus.Pending;
+        payment.price = applicationFee.amount;
+        payment.roundingAmount = 0;
+        payment.method = PaymentMethod.Unknown;
+        payment.type = PaymentType.Payment;
+        payment.createMandate = null;
+
+        payment.provider = PaymentProvider.Stripe;
+        payment.stripeAccountId = stripeAccount.id;
+        await payment.save();
+
+        for (const balanceItem of balanceItems) {
+            // Create one balance item payment to pay it in one payment
+            const balanceItemPayment = new BalanceItemPayment();
+            balanceItemPayment.balanceItemId = balanceItem.id;
+            balanceItemPayment.paymentId = payment.id;
+            balanceItemPayment.organizationId = organization.id;
+            balanceItemPayment.price = balanceItem.priceWithVAT;
+            await balanceItemPayment.save();
+        }
+
+        // Create invoice (before payment, to prevent auto-invoicing)
+        const generalStructs = await AuthenticatedStructures.paymentsGeneral([payment], false);
+
+        const invoiceStruct = InvoiceStruct.create({
+            seller,
+            customer: payment.customer,
+            payments: generalStructs,
+        });
+        invoiceStruct.buildFromPayments();
+
+        invoiceStruct.reference = reference;
+        invoiceStruct.stripeAccountId = accountId;
+
+        await PaymentService.handlePaymentStatusUpdate(payment, sellingOrganization, PaymentStatus.Succeeded, this.end);
+        const invoice = await InvoiceService.createFrom(sellingOrganization, invoiceStruct);
+
+        return invoice;
+    }
+}
+
+export class StripeInvoicer {
+    private stripe: Stripe;
+
+    constructor({ secretKey }: { secretKey: string }) {
+        this.stripe = new Stripe(secretKey, { apiVersion: '2024-06-20', typescript: true, maxNetworkRetries: 1, timeout: 10000 });
+    }
+
+    static getMonthUnixStartEnd(date: Date) {
+        const start = Math.floor((new Date(date.getFullYear(), date.getMonth(), 1, 0, 0, 0, 0).getTime()) / 1000);
+        const end = Math.ceil((new Date(date.getFullYear(), date.getMonth() + 1, 1, 0, 0, 0, 0).getTime() - 1000) / 1000);
+        return { start, end };
+    }
+
+    // Loops all months until all invoices are generated
+    async generateAllInvoices(sellingOrganization: Organization, options?: { force?: boolean; start?: Date }) {
+        const startMonth = options?.start ?? new Date(2026, 0, 1);
+        const stopAt = new Date(Date.now() + (STAMHOOFD.environment === 'production' ? (-60 * 60 * 24 * 1000) : (60 * 60 * 24 * 1000 * 31))); // One day margin before creating invoices
+        let currentMonth = new Date(startMonth);
+
+        while (true) {
+            const { start, end } = StripeInvoicer.getMonthUnixStartEnd(currentMonth);
+
+            if (end >= stopAt.getTime() / 1000) {
+                // Stop
+                break;
+            }
+            await this.generateInvoices(sellingOrganization, currentMonth, options);
+            currentMonth = new Date(currentMonth.getFullYear(), currentMonth.getMonth() + 1, 1);
+        }
+    }
+
+    async generateInvoices(sellingOrganization: Organization, month: Date, options?: { force?: boolean }) {
+        const { start, end } = StripeInvoicer.getMonthUnixStartEnd(month);
+        const reference = 'stripe-fees-' + Formatter.dateIso(new Date(start * 1000));
+
+        try {
+            await QueueHandler.schedule(reference, async () => {
+                if (!options?.force && await StripeReportInvoicer.hasInvoice(sellingOrganization, reference)) {
+                    console.log('Already invoiced month', reference);
+                    return;
+                }
+
+                console.log('Generating invoices for ', reference, start, end);
+                const reportFees = await this.fetchBalanceItems({
+                    created: {
+                        gte: start,
+                        lte: end,
+                    },
+                    type: 'application_fee',
+                    expand: ['data.source', 'data.source.originating_transaction'],
+                });
+                const reportRefund = await this.fetchBalanceItems({
+                    created: {
+                        gte: start,
+                        lte: end,
+                    },
+                    type: 'application_fee_refund',
+                    expand: ['data.source', 'data.source.originating_transaction'],
+                });
+
+                const report = reportFees.combine(reportRefund);
+                const invoicer = new StripeReportInvoicer(report, new Date(start * 1000), new Date(end * 1000));
+                await invoicer.generateInvoices(sellingOrganization, reference);
+            });
+        } catch (e) {
+            console.error(e);
+
+            // Send email notification of this error
+            Email.sendWebmaster({
+                subject: 'Aanmaken Stripe facturen voor ' + Formatter.dateNumber(month) + ' mislukt',
+                html: 'Aanmaken Stripe facturen voor ' + Formatter.dateNumber(month) + ' mislukt. <br><br> ' + e.toString(),
+            });
+        }
+    }
+
+    private async fetchBalanceItems(options: Stripe.BalanceTransactionListParams) {
+        // For the given payout, fetch all balance items
+        const params = { ...options };
+        const report = new StripeReport();
+
+        for await (const balanceItem of this.stripe.balanceTransactions.list(params)) {
+            report.add(balanceItem);
+        }
+
+        return report;
+    }
+}

package/src/helpers/StripePayoutChecker.ts

@@ -53,14 +53,12 @@ export class StripePayoutChecker {
                 // Get all payments for this payout
                 try {
                     await this.fetchBalanceItems(payout);
-                }
-                catch (e) {
+                } catch (e) {
                     console.error('Error for payout ' + payout.id);
                     console.error(e);
                 }
             }
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
         }
     }
@@ -119,8 +117,7 @@ export class StripePayoutChecker {
                             if (stripePayments.length === 1) {
                                 paymentId = stripePayments[0].paymentId;
                                 console.log('Found missing payment metadata for payment intent ', originatingTransaction.payment_intent, paymentId);
-                            }
-                            else {
+                            } else {
                                 // Probably a card payment
                                 // Search for the checkout session
                                 const checkoutSession = await this.stripePlatform.checkout.sessions.list({
@@ -138,12 +135,10 @@ export class StripePayoutChecker {
                                     if (stripeCheckoutSessions.length === 1) {
                                         paymentId = stripeCheckoutSessions[0].paymentId;
                                         console.log('Found missing payment metadata for payment intent ', originatingTransaction.payment_intent, paymentId);
-                                    }
-                                    else {
+                                    } else {
                                         console.log('No payment found for checkout session ' + session.id);
                                     }
-                                }
-                                else {
+                                } else {
                                     console.log('No Stripe Checkout Sessions found for payment intent ' + paymentIntentId);
                                 }
                             }

package/src/helpers/TagHelper.ts

@@ -1,21 +1,22 @@
 import { Organization, Platform } from '@stamhoofd/models';
 import { QueueHandler } from '@stamhoofd/queues';
-import type { OrganizationTag} from '@stamhoofd/structures';
+import type { OrganizationTag } from '@stamhoofd/structures';
 import { AuditLogSource, TagHelper as SharedTagHelper } from '@stamhoofd/structures';
 import { AuditLogService } from '../services/AuditLogService.js';
 
 export class TagHelper extends SharedTagHelper {
     static async updateOrganizations() {
         const queueId = 'update-tags-on-organizations';
-        QueueHandler.cancel(queueId);
+        QueueHandler.abort(queueId);
 
         await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
-            await QueueHandler.schedule(queueId, async () => {
+            await QueueHandler.schedule(queueId, async ({ abort }) => {
                 const sharedPlatform = await Platform.getShared();
 
                 const tagCounts = new Map<string, number>();
 
                 for await (const organization of Organization.select().all()) {
+                    abort.throwIfAborted();
                     organization.meta.tags = this.getAllTagsFromHierarchy(organization.meta.tags, sharedPlatform.config.tags);
 
                     for (const tag of organization.meta.tags) {
@@ -26,11 +27,9 @@ export class TagHelper extends SharedTagHelper {
 
                 // Reload platform to avoid race conditions
                 const platform = await Platform.getForEditing();
-                for (const [tag, count] of tagCounts.entries()) {
-                    const tagObject = platform.config.tags.find(t => t.id === tag);
-                    if (tagObject) {
-                        tagObject.organizationCount = count;
-                    }
+                for (const tagObject of platform.config.tags) {
+                    abort.throwIfAborted();
+                    tagObject.organizationCount = tagCounts.get(tagObject.id) ?? 0;
                 }
                 await platform.save();
             });

package/src/helpers/TemporaryMemberAccess.ts

@@ -33,8 +33,7 @@ export function deleteExpiredTemporaryMemberAccess() {
 
         if (filtered.length === 0) {
             userMemberTemporaryAccessCache.delete(userId);
-        }
-        else {
+        } else {
             userMemberTemporaryAccessCache.set(userId, filtered);
         }
     }

package/src/helpers/ThrottledQueue.ts

@@ -83,8 +83,7 @@ export class ThrottledQueue<T> {
             const batch = batchSize < items.length ? items.slice(i, i + batchSize) : items;
             try {
                 await this.handler(batch);
-            }
-            catch (error) {
+            } catch (error) {
                 console.error('Error processing batch in ThrottledQueue:', error);
             }
         }

package/src/helpers/UitpasTokenRepository.ts

@@ -51,8 +51,7 @@ export class UitpasTokenRepository {
             let repo = new UitpasTokenRepository(model);
             try {
                 await repo.getNewAccessToken();
-            }
-            catch (e) {
+            } catch (e) {
                 return false; // not valid
             }
             // valid -> store