@stamhoofd/backend 2.120.6 → 2.122.0

package/src/services/PlatformMembershipService.ts

@@ -175,7 +175,7 @@ export class PlatformMembershipService {
                 }
                 const types = platform.config.membershipTypes.filter(m => m.behaviour === PlatformMembershipTypeBehaviour.Period).map(m => m.id);
                 if (types.length === 0) {
-                    if (!silent) {
+                    if (!silent && STAMHOOFD.environment !== 'test') {
                         console.warn('No membership types found for memberships');
                     }
                     return;
@@ -353,8 +353,7 @@ export class PlatformMembershipService {
                                 // Update the price and dates of this active membership (could have changed)
                                 try {
                                     await m.calculatePrice(me, cheapestMembership.registration);
-                                }
-                                catch (e) {
+                                } catch (e) {
                                     // Ignore error: membership might not be available anymore
                                     if (!silent) {
                                         console.error('Failed to calculate price for active membership', m.id, e);
@@ -377,14 +376,12 @@ export class PlatformMembershipService {
                                     console.log('Removing membership because cheaper membership found or duplicate, for: ' + me.id + ' - membership ' + m.id);
                                 }
                                 await m.doDelete();
-                            }
-                            else if (m.membershipTypeId === cheapestMembership.membership.id) {
+                            } else if (m.membershipTypeId === cheapestMembership.membership.id) {
                                 // Update price
                                 if (!m.locked) {
                                     try {
                                         await m.calculatePrice(me);
-                                    }
-                                    catch (e) {
+                                    } catch (e) {
                                     // Ignore error: membership might not be available anymore
                                         if (!silent) {
                                             console.error('Failed to calculate price for undeletable membership', m.id, e);
@@ -409,8 +406,7 @@ export class PlatformMembershipService {
                     if (me.details.memberNumber === null) {
                         try {
                             await MemberNumberService.assignMemberNumber(me, membership);
-                        }
-                        catch (error) {
+                        } catch (error) {
                             console.error(`Failed to assign member number for id ${me.id}: ${error.message}`);
                             // If the assignment of the member number fails the membership is not created but the member is registered
                             continue;

package/src/services/ReferralService.ts

@@ -0,0 +1,223 @@
+import type { Model } from '@simonbackx/simple-database';
+import { SimpleError } from '@simonbackx/simple-errors';
+import type { EmailInterfaceBase } from '@stamhoofd/email';
+import { Email } from '@stamhoofd/email';
+import { BalanceItem, Organization, Platform, RegisterCode, UsedRegisterCode } from '@stamhoofd/models';
+import { BalanceItemStatus, BalanceItemType } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
+import { VATService } from './VATService.js';
+
+export class ReferralService {
+    /**
+     * Prepares a register code for usage.
+     * Returns the models to save and the emails to send when succesful
+     */
+    static async markUsed(organization: Organization, codeString: string): Promise<{ models: Model[]; emails: EmailInterfaceBase[] }> {
+        const alreadyUsed = await UsedRegisterCode.getFor(organization.id);
+        if (alreadyUsed) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid register code',
+                human: $t('%1Ws'),
+                field: 'registerCode',
+            });
+        }
+
+        const code = await RegisterCode.getByID(codeString);
+        if (!code) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Invalid register code',
+                human: $t('%1Ua'),
+                field: 'registerCode',
+            });
+        }
+
+        const otherOrganization = code.organizationId ? await Organization.getByID(code.organizationId) : undefined;
+
+        const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
+        if (!membershipOrganizationId) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Referral codes unavailable',
+                human: $t('%1YF'),
+                field: 'registerCode',
+            });
+        }
+        const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+        const delayEmails: EmailInterfaceBase[] = [];
+        let credit: BalanceItem | undefined = undefined;
+
+        if (code.value > 0) {
+            credit = new BalanceItem();
+            credit.type = BalanceItemType.ReferralDiscount;
+            credit.description = otherOrganization ? ('Tegoed gekregen van ' + otherOrganization.name) : code.description;
+            credit.payingOrganizationId = organization.id;
+            credit.organizationId = membershipOrganization.id;
+            credit.VATPercentage = 21;
+            credit.VATExcempt = VATService.getVATExcempt({
+                company: organization.defaultCompanies[0] ?? null,
+                sellingOrganization: membershipOrganization,
+                type: 'services',
+            });
+            credit.VATIncluded = false;
+            credit.quantity = 1;
+            credit.unitPrice = -code.value;
+            credit.createdAt = new Date();
+            credit.status = BalanceItemStatus.Due;
+
+            // Expire in one year (will get extended for every purchase or activation)
+            // credit.expireAt = new Date()
+            // credit.expireAt.setFullYear(credit.expireAt.getFullYear() + 1)
+            // credit.expireAt.setMilliseconds(0)
+
+            // Save later
+        }
+
+        if (otherOrganization) {
+            const admins = await otherOrganization.getAdminToEmails();
+            if (admins) {
+                if (code.invoiceValue) {
+                    // Delay email until everything is validated and saved
+                    delayEmails.push({
+                        to: admins,
+                        subject: organization.name + ' heeft jullie doorverwijzingslink gebruikt 🥳',
+                        type: 'transactional',
+                        text: 'Dag ' + otherOrganization.name + ',\n\nGoed nieuws! ' + organization.name + ' heeft jullie doorverwijzingslink gebruikt om zich op Stamhoofd te registreren.\n\n— Stamhoofd',
+                    });
+                } else {
+                    // Delay email until everything is validated and saved
+                    delayEmails.push({
+                        to: admins,
+                        subject: organization.name + ' heeft jullie doorverwijzingslink gebruikt 🥳',
+                        type: 'transactional',
+                        text: 'Dag ' + otherOrganization.name + ',\n\nGoed nieuws! ' + organization.name + ' heeft jullie doorverwijzingslink gebruikt om zich op Stamhoofd te registreren. Als zij minstens 1 euro op Stamhoofd uitgeven ontvangen jullie een tegoed dat kan oplopen tot 100 euro per vereniging (zie daarvoor Stamhoofd > Instellingen). Lees zeker onze tips na om nog een groter bedrag te verzamelen.\n\n— Stamhoofd',
+                    });
+                }
+            }
+        } else {
+            delayEmails.push({
+                to: [
+                    { email: 'hallo@stamhoofd.be' },
+                ],
+                subject: organization.name + ' heeft jullie doorverwijzingslink gebruikt 🥳',
+                type: 'transactional',
+                text: 'Dag Stamhoofd,\n\nGoed nieuws! ' + organization.name + ' heeft jullie doorverwijzingslink ' + code.code + ' gebruikt om zich op Stamhoofd te registreren. \n\n— Stamhoofd',
+            });
+        }
+
+        // Save that we used this code (so we can reward the other organization)
+        const usedCode = new UsedRegisterCode();
+        usedCode.organizationId = organization.id;
+        usedCode.code = code.code;
+
+        // Save later
+        return {
+            models: credit ? [credit, usedCode] : [usedCode],
+            emails: delayEmails,
+        };
+    }
+
+    static async reward(usedCode: UsedRegisterCode) {
+        if (usedCode.balanceItemId) {
+            // Already received
+            console.error('Already rewarded for used register code ' + usedCode.id);
+            return;
+        }
+
+        const code = await RegisterCode.getByID(usedCode.code);
+        if (!code || !code.organizationId) {
+            console.error("Couldn't find code " + usedCode.code + ' for used register code ' + usedCode.id);
+            return;
+        }
+
+        const organization = await Organization.getByID(usedCode.organizationId);
+        if (!organization) {
+            console.error("Couldn't find organization with id " + usedCode.organizationId + ' for used register code ' + usedCode.id);
+            return;
+        }
+
+        const receivingOrganization = await Organization.getByID(code.organizationId);
+        if (!receivingOrganization) {
+            console.error("Couldn't find receiving organization with id " + code.organizationId + ' for used register code ' + usedCode.id);
+            return;
+        }
+        const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId!;
+        const membershipOrganization = await Organization.getByID(membershipOrganizationId, true);
+
+        const usedCount = await UsedRegisterCode.getUsedCount(usedCode.code) + 1;
+
+        const credit = new BalanceItem();
+        credit.type = BalanceItemType.ReferralDiscount;
+        credit.description = $t('%1ZE', { 'organization-name': organization.name });
+        credit.payingOrganizationId = code.organizationId;
+        credit.organizationId = (await Platform.getShared()).membershipOrganizationId!; // where do we get this discount from
+        credit.VATPercentage = 21;
+        credit.VATExcempt = VATService.getVATExcempt({
+            company: organization.defaultCompanies[0] ?? null,
+            sellingOrganization: membershipOrganization,
+            type: 'services',
+        });
+        credit.VATIncluded = false;
+        credit.quantity = 1;
+        credit.unitPrice = -(code.invoiceValue ? 0 : Math.min(100 * 100_00, usedCount * 10 * 100_00));
+        credit.createdAt = new Date();
+        credit.status = BalanceItemStatus.Due;
+
+        // Expire in one year (will get extended for every purchase or activation)
+        // credit.expireAt = new Date()
+        // credit.expireAt.setFullYear(credit.expireAt.getFullYear() + 1)
+        // credit.expireAt.setMilliseconds(0)
+
+        await credit.save();
+
+        usedCode.balanceItemId = credit.id;
+        await usedCode.save();
+
+        if (code.invoiceValue) {
+            // The receiving organization is invoiced instead of the organization for the usage of Stamhoofd.
+            const item = new BalanceItem();
+            item.type = BalanceItemType.Other;
+            item.description = 'Aankoop Stamhoofd voor ' + organization.name;
+            item.payingOrganizationId = receivingOrganization.id;
+            item.organizationId = membershipOrganizationId;
+            item.VATPercentage = 21;
+            item.VATExcempt = VATService.getVATExcempt({
+                company: organization.defaultCompanies[0] ?? null,
+                sellingOrganization: membershipOrganization,
+                type: 'services',
+            });
+            item.VATIncluded = false;
+            item.quantity = 1;
+            item.unitPrice = code.invoiceValue;
+            item.createdAt = new Date();
+            item.status = BalanceItemStatus.Due;
+            await item.save();
+        }
+
+        const admins = await receivingOrganization.getAdminRecipients();
+        if (admins) {
+            if (code.invoiceValue) {
+                Email.send({
+                    to: admins,
+                    from: Email.getQuickFromEmail(receivingOrganization.address.country),
+                    subject: `${organization.name} heeft jullie tegoed gebruikt`,
+                    text: 'Dag ' + receivingOrganization.name + ',\n\n' + organization.name + ' had jullie doorverwijzingslink gebruikt om zich op Stamhoofd te registreren, en nu hebben ze dit ook gebruikt. Zoals afgesproken wordt hiervoor ' + Formatter.price(code.invoiceValue) + ' aangerekend via jullie openstaand saldo in jullie Stamhoofd account.'
+                        + '\n\n— Stamhoofd',
+                });
+            } else {
+                // Delay email until everything is validated and saved
+                Email.send({
+                    from: Email.getQuickFromEmail(receivingOrganization.address.country),
+                    to: admins,
+                    subject: 'Je hebt ' + Formatter.price(-credit.unitPrice) + ' tegoed ontvangen 💰',
+                    text: 'Dag ' + receivingOrganization.name + ',\n\nGeweldig nieuws! ' + organization.name + ' had jullie doorverwijzingslink gebruikt om zich op Stamhoofd te registreren, en nu hebben ze ook voor het eerst minstens één euro uitgegeven. Daardoor ontvangen jullie ' + Formatter.price(-credit.unitPrice) + ' tegoed voor Stamhoofd (zie daarvoor Stamhoofd > Instellingen). '
+                        + (-credit.unitPrice <= 90 * 100_00 ? ('Bij de volgende vereniging ontvangen jullie nog meer: ' + Formatter.price(-credit.unitPrice + 10 * 100_00) + '. ') : '')
+                        + (-credit.unitPrice <= 80 * 100_00 ? ('En dat blijft oplopen tot € 100,00 per vereniging die je aanbrengt.') : '')
+                        + 'Doe zo verder! Lees zeker onze tips na om nog een groter bedrag te verzamelen.\n\n— Stamhoofd',
+                });
+            }
+        }
+    }
+}

package/src/services/RegistrationService.ts

@@ -1,12 +1,12 @@
 import { ManyToOneRelation } from '@simonbackx/simple-database';
-import { BalanceItem, Document, Group, Member, Organization, Registration, sendEmailTemplate } from '@stamhoofd/models';
-import { AppliedRegistrationDiscount, AuditLogSource, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, EmailTemplateType, Recipient, Replacement, StockReservation, TranslatedString, Version } from '@stamhoofd/structures';
+import { encodeObject } from '@simonbackx/simple-encoding';
+import { BalanceItem, Document, Group, Member, Organization, Registration, RegistrationInvitation, sendEmailTemplate } from '@stamhoofd/models';
+import { QueueHandler } from '@stamhoofd/queues';
+import { AppliedRegistrationDiscount, AuditLogSource, BalanceItemRelationType, BalanceItemStatus, BalanceItemType, EmailTemplateType, getAppHost, GroupType, Recipient, Replacement, StockReservation, Version } from '@stamhoofd/structures';
+import { Formatter } from '@stamhoofd/utility';
 import { AuditLogService } from './AuditLogService.js';
 import { GroupService } from './GroupService.js';
 import { PlatformMembershipService } from './PlatformMembershipService.js';
-import { QueueHandler } from '@stamhoofd/queues';
-import { Formatter } from '@stamhoofd/utility';
-import { encodeObject } from '@simonbackx/simple-encoding';
 
 export const RegistrationService = {
     /**
@@ -55,6 +55,8 @@ export const RegistrationService = {
         await registration.save();
         RegistrationService.scheduleStockUpdate(registration.id);
 
+        await this.handleWaitingListRegistrationAndInvitation(registration);
+
         await PlatformMembershipService.updateMembershipsForId(registration.memberId);
 
         if (registration.sendConfirmationEmail) {
@@ -76,6 +78,65 @@ export const RegistrationService = {
         return true;
     },
 
+    /**
+     * Delete all the invitations for the group and member linked to the registration.
+     * Will not throw if it fails.
+     * @param registration
+     */
+    async handleWaitingListRegistrationAndInvitation(registration: Registration): Promise<void> {
+        const group = await Group.getByID(registration.groupId);
+
+        if (!group || group.type === GroupType.WaitingList) {
+            // skip if waiting list (waiting lists cannot have invitations)
+            return;
+        }
+
+        // get invitation for this group and member (can only be 1)
+        const invitation = await RegistrationInvitation.select()
+            .where('groupId', registration.groupId)
+            .andWhere('memberId', registration.memberId)
+            .first(false);
+
+        const waitingListIds = new Set<string>();
+
+        if (group.waitingListId) {
+            // we should check if the member is on the waiting list of this group
+            waitingListIds.add(group.waitingListId);
+        }
+
+        if (invitation) {
+            // delete the invitation
+            try {
+                await invitation.delete();
+            } catch (e) {
+                // an error should not stop other logic (impact of an error is low)
+                console.error(e);
+            }
+        }
+
+        // unsubscribe from waiting list
+        if (group.waitingListId) {
+            try {
+                // get the registration for the waiting list (should only be 1)
+                const waitingListRegistration = await Registration.select()
+                    .where('groupId', group.waitingListId)
+                    .where('memberId', registration.memberId)
+                    .where('deactivatedAt', null)
+                    .whereNot('registeredAt', null)
+                    .first(false);
+
+                if (waitingListRegistration) {
+                    // unsubscribe for waiting list (waiting lists cannot have a price -> balance items should not be updated)
+                    await RegistrationService.deactivate(waitingListRegistration);
+                    await GroupService.updateOccupancy(group.waitingListId);
+                }
+            } catch (e) {
+                // an error should not stop other logic (impact of an error is low)
+                console.error(e);
+            }
+        }
+    },
+
     async getRecipients(registration: Registration, organization: Organization, group: Group) {
         const member = await Member.getByIdWithUsers(registration.memberId);
 
@@ -101,7 +162,7 @@ export const RegistrationService = {
                 }),
                 Replacement.create({
                     token: 'registerUrl',
-                    value: 'https://' + organization.getHost(),
+                    value: 'https://' + getAppHost('registration', organization, user.permissions?.forOrganization(organization)?.isEmpty === false),
                 }),
                 Replacement.create({
                     token: 'groupName',
@@ -223,9 +284,65 @@ export const RegistrationService = {
      * + in combination with validation and reading the webshop
      */
     scheduleStockUpdate(id: string) {
+        this.scheduleStockUpdateAsync(id);
+    },
+
+    /**
+     * Avoid calling this method directly. This can cause race conditions.
+     */
+    async unsafeStockUpdate(updated: Registration) {
+        // Start with clearing all the stock reservations we've already made
+        if (updated.stockReservations) {
+            const groupIds = Formatter.uniqueArray(updated.stockReservations.flatMap(r => r.objectType === 'Group' ? [r.objectId] : []));
+            for (const groupId of groupIds) {
+                const stocks = StockReservation.filter('Group', groupId, updated.stockReservations);
+
+                // Technically we don't need to await this, but okay...
+                await Group.freeStockReservations(groupId, stocks);
+            }
+        }
+
+        if (updated.shouldIncludeStock()) {
+            const groupStockReservations: StockReservation[] = [
+            // Group level stock reservations (stored in the group)
+                StockReservation.create({
+                    objectId: updated.groupPrice.id,
+                    objectType: 'GroupPrice',
+                    amount: 1,
+                }),
+                ...updated.options.map((o) => {
+                    return StockReservation.create({
+                        objectId: o.option.id,
+                        objectType: 'GroupOption',
+                        amount: o.amount,
+                    });
+                }),
+            ];
+
+            await Group.applyStockReservations(updated.groupId, groupStockReservations);
+
+            updated.stockReservations = [
+            // Global level stock reservations (stored in each group)
+                StockReservation.create({
+                    objectId: updated.groupId,
+                    objectType: 'Group',
+                    amount: 1,
+                    children: groupStockReservations,
+                }),
+            ];
+            await updated.save();
+        } else {
+            if (updated.stockReservations.length) {
+                updated.stockReservations = [];
+                await updated.save();
+            }
+        }
+    },
+
+    async scheduleStockUpdateAsync(id: string) {
         QueueHandler.cancel('registration-stock-update-' + id);
 
-        AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
+        await AuditLogService.setContext({ source: AuditLogSource.System }, async () => {
             await QueueHandler.schedule('registration-stock-update-' + id, async function (this: undefined) {
                 const updated = await Registration.getByID(id);
 
@@ -233,53 +350,7 @@ export const RegistrationService = {
                     return;
                 }
 
-                // Start with clearing all the stock reservations we've already made
-                if (updated.stockReservations) {
-                    const groupIds = Formatter.uniqueArray(updated.stockReservations.flatMap(r => r.objectType === 'Group' ? [r.objectId] : []));
-                    for (const groupId of groupIds) {
-                        const stocks = StockReservation.filter('Group', groupId, updated.stockReservations);
-
-                        // Technically we don't need to await this, but okay...
-                        await Group.freeStockReservations(groupId, stocks);
-                    }
-                }
-
-                if (updated.shouldIncludeStock()) {
-                    const groupStockReservations: StockReservation[] = [
-                    // Group level stock reservations (stored in the group)
-                        StockReservation.create({
-                            objectId: updated.groupPrice.id,
-                            objectType: 'GroupPrice',
-                            amount: 1,
-                        }),
-                        ...updated.options.map((o) => {
-                            return StockReservation.create({
-                                objectId: o.option.id,
-                                objectType: 'GroupOption',
-                                amount: o.amount,
-                            });
-                        }),
-                    ];
-
-                    await Group.applyStockReservations(updated.groupId, groupStockReservations);
-
-                    updated.stockReservations = [
-                    // Global level stock reservations (stored in each group)
-                        StockReservation.create({
-                            objectId: updated.groupId,
-                            objectType: 'Group',
-                            amount: 1,
-                            children: groupStockReservations,
-                        }),
-                    ];
-                    await updated.save();
-                }
-                else {
-                    if (updated.stockReservations.length) {
-                        updated.stockReservations = [];
-                        await updated.save();
-                    }
-                }
+                await RegistrationService.unsafeStockUpdate(updated);
             });
         }).catch(console.error);
     },

package/src/services/SSOService.test.ts

@@ -0,0 +1,119 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Request } from '@simonbackx/simple-endpoints';
+import { Platform } from '@stamhoofd/models';
+import { LoginMethod, LoginMethodConfig, LoginProviderType, OpenIDClientConfiguration } from '@stamhoofd/structures';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+import { ContextInstance } from '../helpers/Context.js';
+import { SSOService } from './SSOService.js';
+
+describe('SSOService', () => {
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+
+    describe('fromContext', () => {
+        it('does not validate by default', async () => {
+            mockPlatform({
+                ssoConfiguration: OpenIDClientConfiguration.create({}),
+                loginMethods: new Map(),
+            });
+
+            const service = await runWithContext(() => SSOService.fromContext(LoginProviderType.SSO));
+
+            expect(service).toBeInstanceOf(SSOService);
+        });
+
+        it('validates when requested explicitly', async () => {
+            mockPlatform({
+                ssoConfiguration: OpenIDClientConfiguration.create({}),
+                loginMethods: new Map(),
+            });
+
+            await expect(runWithContext(() => SSOService.fromContext(LoginProviderType.SSO, { validate: true }))).rejects.toThrow('SSO not configured (correctly)');
+        });
+    });
+
+    describe('validateConfiguration', () => {
+        it('validates the OpenID client configuration getter', () => {
+            const service = createService({
+                googleConfiguration: null,
+                loginMethods: new Map([[LoginMethod.Google, LoginMethodConfig.create({})]]),
+                provider: LoginProviderType.Google,
+                organization: {},
+            });
+
+            expect(() => service.validateConfiguration()).toThrow(SimpleError);
+            expect(() => service.validateConfiguration()).toThrow('SSO not configured');
+        });
+
+        it('validates the login method configuration getter', () => {
+            const service = createService({
+                ssoConfiguration: OpenIDClientConfiguration.create({}),
+                loginMethods: new Map(),
+                provider: LoginProviderType.SSO,
+            });
+
+            expect(() => service.validateConfiguration()).toThrow(SimpleError);
+            expect(() => service.validateConfiguration()).toThrow('SSO not configured (correctly)');
+        });
+
+        it('accepts complete SSO configuration', () => {
+            const service = createService({
+                ssoConfiguration: OpenIDClientConfiguration.create({}),
+                loginMethods: new Map([[LoginMethod.SSO, LoginMethodConfig.create({})]]),
+                provider: LoginProviderType.SSO,
+            });
+
+            expect(() => service.validateConfiguration()).not.toThrow();
+        });
+    });
+});
+
+async function runWithContext<T>(handler: () => Promise<T>) {
+    const context = new ContextInstance(new Request({
+        method: 'GET',
+        url: '/',
+        host: '',
+    }));
+
+    return await ContextInstance.asyncLocalStorage.run(context, handler);
+}
+
+function mockPlatform(options: {
+    loginMethods: Map<LoginMethod, LoginMethodConfig>;
+    ssoConfiguration?: OpenIDClientConfiguration | null;
+    googleConfiguration?: OpenIDClientConfiguration | null;
+}) {
+    vi.spyOn(Platform, 'getForEditing').mockResolvedValue(createPlatform(options));
+}
+
+function createService(options: {
+    provider: LoginProviderType;
+    loginMethods: Map<LoginMethod, LoginMethodConfig>;
+    ssoConfiguration?: OpenIDClientConfiguration | null;
+    googleConfiguration?: OpenIDClientConfiguration | null;
+    organization?: any;
+}) {
+    return new SSOService({
+        provider: options.provider,
+        platform: createPlatform(options),
+        organization: options.organization,
+    });
+}
+
+function createPlatform(options: {
+    loginMethods: Map<LoginMethod, LoginMethodConfig>;
+    ssoConfiguration?: OpenIDClientConfiguration | null;
+    googleConfiguration?: OpenIDClientConfiguration | null;
+}) {
+    return {
+        config: {
+            loginMethods: options.loginMethods,
+        },
+        serverConfig: {
+            ssoConfiguration: options.ssoConfiguration,
+            googleConfiguration: options.googleConfiguration,
+        },
+    } as any;
+}