@stamhoofd/models 2.115.0 → 2.116.0

package/src/models/Group.ts

@@ -1,12 +1,11 @@
-import { column, Database, ManyToOneRelation, OneToManyRelation } from '@simonbackx/simple-database';
+import { column, Database, ManyToOneRelation } from '@simonbackx/simple-database';
 import { GroupCategory, 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 { Formatter } from '@stamhoofd/utility';
-import { Member, MemberWithRegistrations, OrganizationRegistrationPeriod, Payment, Registration, User } from './index.js';
+import { ModelCache, QueryableModel } from '@stamhoofd/sql';
+import { Member, OrganizationRegistrationPeriod, Payment, Registration, User } from './index.js';
 
 if (Member === undefined) {
     throw new Error('Import Member is undefined');
@@ -23,6 +22,7 @@ if (Registration === undefined) {
 
 export class Group extends QueryableModel {
     static table = 'groups';
+    // static cache = new ModelCache<Group>();
 
     @column({
         primary: true, type: 'string', beforeSave(value) {
@@ -135,73 +135,6 @@ export class Group extends QueryableModel {
         return [...map.values()];
     }
 
-    /**
-     * Fetch all members with their corresponding (valid) registrations, users
-     */
-    async getMembersWithRegistration(waitingList = false, cycleOffset = 0): Promise<MemberWithRegistrations[]> {
-        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()}, ${User.getDefaultSelect()} from \`${Member.table}\`\n`;
-
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`;
-
-        if (waitingList) {
-            query += `JOIN \`${Registration.table}\` as reg_filter ON reg_filter.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND reg_filter.\`waitingList\` = 1\n`;
-        }
-        else {
-            query += `JOIN \`${Registration.table}\` as reg_filter ON reg_filter.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND reg_filter.\`waitingList\` = 0 AND reg_filter.\`registeredAt\` is not null\n`;
-        }
-
-        query += Member.users.joinQuery(Member.table, User.table) + '\n';
-
-        // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
-        query += `where reg_filter.\`groupId\` = ? AND reg_filter.\`cycle\` = ?`;
-
-        const [results] = await Database.select(query, [this.id, this.cycle - cycleOffset]);
-        const members: MemberWithRegistrations[] = [];
-
-        const groupIds = results.map(r => r[Registration.table]?.groupId).filter(id => id) as string[];
-        const groups = await Group.getByIDs(...Formatter.uniqueArray(groupIds));
-
-        for (const row of results) {
-            const foundMember = Member.fromRow(row[Member.table]);
-            if (!foundMember) {
-                throw new Error('Expected member in every row');
-            }
-            const _f = foundMember.setManyRelation(Member.registrations as unknown as OneToManyRelation<'registrations', Member, Registration & { group: Group }>, []).setManyRelation(Member.users, []);
-
-            // Seach if we already got this member?
-            const existingMember = members.find(m => m.id == _f.id);
-
-            const member: MemberWithRegistrations = (existingMember ?? _f);
-            if (!existingMember) {
-                members.push(member);
-            }
-
-            // Check if we have a registration with a payment
-            const registration = Registration.fromRow(row[Registration.table]);
-            if (registration) {
-                // Check if we already have this registration
-                if (!member.registrations.find(r => r.id == registration.id)) {
-                    const group = groups.find(g => g.id == registration.groupId);
-                    if (!group) {
-                        throw new Error('Expected group');
-                    }
-                    member.registrations.push(registration.setRelation(Registration.group, group));
-                }
-            }
-
-            // Check if we have a user
-            const user = User.fromRow(row[User.table]);
-            if (user) {
-                // Check if we already have this registration
-                if (!member.users.find(r => r.id == user.id)) {
-                    member.users.push(user);
-                }
-            }
-        }
-
-        return members;
-    }
-
     /**
      * @deprecated
      */

package/src/models/Member.ts

@@ -1,22 +1,32 @@
 import { column, Database, ManyToManyRelation, ManyToOneRelation, OneToManyRelation } from '@simonbackx/simple-database';
-import { QueryableModel, SQL } from '@stamhoofd/sql';
+import { ModelCache, QueryableModel, SQL } from '@stamhoofd/sql';
 import { MemberDetails, NationalRegisterNumberOptOut, RegistrationWithTinyMember, TinyMember } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 
-import { Group, MemberResponsibilityRecord, Payment, Registration, User } from './index.js';
+import { Group, MemberResponsibilityRecord, MemberUser, Payment, Registration, User } from './index.js';
 export type MemberWithUsers = Member & {
     users: User[];
 };
-export type MemberWithRegistrations = MemberWithUsers & {
-    registrations: (Registration & { group: Group })[];
+export type MemberWithRegistrations<R extends Registration = Registration> = Member & {
+    registrations: (R)[];
 };
+export type RegistrationWithGroup = Registration & { group: Group };
+export type MemberWithRegistrationsAndGroups = MemberWithRegistrations<RegistrationWithGroup>;
+export type MemberWithUsersAndRegistrations<R extends Registration = Registration> = MemberWithUsers & MemberWithRegistrations<R>;
+
+/**
+ * @deprecated
+ * For performance reasons, avoid loading the groups of registrations when not required. Use MemberWithRegistrations instead.
+ */
+export type MemberWithUsersRegistrationsAndGroups = MemberWithUsers & MemberWithUsersAndRegistrations<RegistrationWithGroup>;
 
 // Defined here to prevent cycles
 export type RegistrationWithMember = Registration & { member: Member };
 
 export class Member extends QueryableModel {
     static table = 'members';
+    // static cache = new ModelCache<Member>();
 
     // #region Columns
     @column({
@@ -102,10 +112,51 @@ export class Member extends QueryableModel {
     /**
      * Fetch all members with their corresponding (valid) registration
      */
-    static async getWithRegistrations(id: string): Promise<MemberWithRegistrations | null> {
+    static async getWithRegistrations(id: string): Promise<MemberWithUsersRegistrationsAndGroups | null> {
         return (await this.getBlobByIds(id))[0] ?? null;
     }
 
+    /**
+     * Fetch all members with their corresponding (valid) registration
+     */
+    static async getByIdWithRegistrationsAndGroups(id: string): Promise<MemberWithRegistrationsAndGroups | null> {
+        const member = await this.getByID(id);
+        if (!member) {
+            return null;
+        }
+        await this.loadRegistrations([member], true);
+        return member as MemberWithRegistrationsAndGroups;
+    }
+
+    /**
+     * Fetch all members with their corresponding (valid) registration
+     */
+    static async getByIdWithUsers(id: string): Promise<MemberWithUsers | null> {
+        const member = await this.getByID(id);
+        if (!member) {
+            return null;
+        }
+        await this.loadUsers([member]);
+        return member as MemberWithUsers;
+    }
+
+    /**
+     * Fetch all members with their corresponding (valid) registration
+     */
+    static async getByIdWithUsersAndRegistrations(id: string): Promise<MemberWithUsersAndRegistrations | null> {
+        const member = await this.getByID(id);
+        if (!member) {
+            return null;
+        }
+        await this.loadRegistrationsAndUsers([member]);
+        return member as MemberWithUsersAndRegistrations;
+    }
+
+    static async getByIdsWithUsers(...ids: string[]): Promise<MemberWithUsers[]> {
+        const members = await Member.getByIDs(...ids);
+        return await Member.loadUsers(members);
+    }
+
     /**
      * Fetch all registrations with members with their corresponding (valid) registrations
      */
@@ -113,195 +164,243 @@ export class Member extends QueryableModel {
         if (ids.length === 0) {
             return [];
         }
-        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()} from \`${Member.table}\`\n`;
 
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`canRegister\` = 1)\n`;
-
-        // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
-        query += `where \`${Registration.table}\`.\`${Registration.primary.name}\` IN (?)`;
-
-        const [results] = await Database.select(query, [ids]);
-        const registrations: RegistrationWithMember[] = [];
-
-        // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
-        const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
-        registrationMemberRelation.foreignKey = Member.registrations.foreignKey;
+        const registrations = await Registration.getByIDs(...ids);
+        await this.loadMembersForRegistrations(registrations);
+        return registrations as RegistrationWithMember[];
+    }
 
-        for (const row of results) {
-            const registration = Registration.fromRow(row[Registration.table]);
-            if (!registration) {
-                throw new Error('Expected registration in every row');
-            }
+    /**
+     * Fetch all registrations with members with their corresponding (valid) registrations
+     */
+    static async loadMembersForRegistrations(registrations: Registration[]): Promise<RegistrationWithMember[]> {
+        if (registrations.length === 0) {
+            return [];
+        }
 
-            const foundMember = Member.fromRow(row[Member.table]);
-            if (!foundMember) {
-                throw new Error('Expected member in every row');
+        const memberIds = Formatter.uniqueArray(registrations.map(r => r.memberId));
+        if (memberIds.length) {
+            // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
+            const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
+            registrationMemberRelation.foreignKey = Member.registrations.foreignKey;
+
+            const members = await Member.getByIDs(...memberIds);
+            for (const registration of registrations) {
+                const member = members.find(m => m.id === registration.memberId);
+                if (member) {
+                    registration.setRelation(registrationMemberRelation, member);
+                }
+                else {
+                    throw new Error('Unexpected missing member for registration ' + registration.id);
+                }
             }
-
-            const _f = registration.setRelation(registrationMemberRelation, foundMember);
-            registrations.push(_f);
         }
 
-        return registrations;
+        return registrations as RegistrationWithMember[];
     }
 
     /**
      * Fetch all registrations with members with their corresponding (valid) registrations
      */
     static async getRegistrationWithMembersForGroup(groupId: string): Promise<RegistrationWithMember[]> {
-        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()} from \`${Member.table}\`\n`;
+        const registrations = await Registration.select()
+            .where('groupId', groupId)
+            .where('registeredAt', '!=', null)
+            .where('deactivatedAt', null)
+            .fetch();
 
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND \`${Registration.table}\`.\`registeredAt\` is not null AND \`${Registration.table}\`.\`deactivatedAt\` is null\n`;
+        return this.loadMembersForRegistrations(registrations);
+    }
 
-        // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
-        query += `where \`${Registration.table}\`.\`groupId\` = ?`;
+    static async loadRegistrations(members: Member[], withGroups?: false): Promise<MemberWithRegistrations[]>;
+    static async loadRegistrations(members: Member[], withGroups: true): Promise<MemberWithRegistrationsAndGroups[]>;
+    static async loadRegistrations(members: Member[], withGroups: boolean | undefined = true): Promise<MemberWithRegistrations[] | MemberWithRegistrationsAndGroups[]> {
+        if (members.length === 0) {
+            return members as MemberWithRegistrations[];
+        }
 
-        const [results] = await Database.select(query, [groupId]);
-        const registrations: RegistrationWithMember[] = [];
+        // Load relations
+        // Load registrations of these members
+        const loadAllFor: string[] = [];
+        const alreadyLoadedRegistrations: (Registration | undefined)[] = [];
 
-        // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
-        const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
-        registrationMemberRelation.foreignKey = Member.registrations.foreignKey;
+        for (const member of members) {
+            if ('registrations' in member && Array.isArray(member.registrations)) {
+                if (member.registrations.length === 0) {
+                    // Nothing to do
+                    continue;
+                }
 
-        for (const row of results) {
-            const registration = Registration.fromRow(row[Registration.table]);
-            if (!registration) {
-                throw new Error('Expected registration in every row');
+                alreadyLoadedRegistrations.push(...member.registrations as Registration[]);
+                continue;
             }
+            loadAllFor.push(member.id);
+        }
 
-            const foundMember = Member.fromRow(row[Member.table]);
-            if (!foundMember) {
-                throw new Error('Expected member in every row');
+        const ids = Formatter.uniqueArray(loadAllFor);
+        if (ids.length) {
+            const registrations = await Registration.select()
+                .where('memberId', ids)
+                .where(
+                    SQL.where('registeredAt', '!=', null),
+                )
+                .fetch() as (Registration | undefined)[];
+            alreadyLoadedRegistrations.push(...registrations);
+        }
+        else {
+            if (!withGroups) {
+                return members as MemberWithRegistrations[];
             }
-
-            const _f = registration.setRelation(registrationMemberRelation, foundMember);
-            registrations.push(_f);
         }
 
-        return registrations;
-    }
+        if (withGroups) {
+            const groupIds = Formatter.uniqueArray(alreadyLoadedRegistrations.map(r => r && 'group' in r ? undefined : r?.groupId));
+            if (groupIds.length) {
+                const groups = await Group.getByIDs(...groupIds);
 
-    /**
-     * Fetch all registrations with members with their corresponding (valid) registrations and payment
-     */
-    static async getRegistrationWithMembersForPayment(paymentId: string): Promise<RegistrationWithMember[]> {
-        const { BalanceItem, BalanceItemPayment } = await import('./index.js');
-
-        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()} from \`${Member.table}\`\n`;
+                for (const [index, registration] of alreadyLoadedRegistrations.entries()) {
+                    if ('group' in registration!) {
+                        continue;
+                    }
+                    const group = groups.find(g => g.id === registration!.groupId);
+                    if (group && !group.deletedAt) {
+                        registration!.setRelation(Registration.group, group);
+                    }
+                    else {
+                        // Remove registration from list
+                        alreadyLoadedRegistrations[index] = undefined;
+                    }
+                }
+            }
+            else {
+                if (ids.length === 0) {
+                    // Nothing loaded
+                    return members as MemberWithRegistrations[];
+                }
+            }
+        }
 
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\`\n`;
+        for (const member of members) {
+            // Add registrations
+            const memberRegistrations = alreadyLoadedRegistrations.filter(r => !!r && r.memberId === member.id) as Registration[];
+            member.setManyRelation(Member.registrations, memberRegistrations);
+        }
 
-        query += `LEFT JOIN \`${BalanceItem.table}\` ON \`${BalanceItem.table}\`.\`registrationId\` = \`${Registration.table}\`.\`${Registration.primary.name}\`\n`;
-        query += `LEFT JOIN \`${BalanceItemPayment.table}\` ON \`${BalanceItemPayment.table}\`.\`${BalanceItemPayment.balanceItem.foreignKey}\` = \`${BalanceItem.table}\`.\`${BalanceItem.primary.name}\`\n`;
-        query += `JOIN \`${Payment.table}\` ON \`${Payment.table}\`.\`${Payment.primary.name}\` = \`${BalanceItemPayment.table}\`.\`${BalanceItemPayment.payment.foreignKey}\`\n`;
+        return members as MemberWithRegistrations[];
+    }
 
-        // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
-        query += `WHERE \`${Payment.table}\`.\`${Payment.primary.name}\` = ?\n`;
-        query += `GROUP BY \`${Registration.table}\`.\`${Registration.primary.name}\`, \`${Member.table}\`.\`${Member.primary.name}\``;
+    static async loadUsers(members: Member[]): Promise<MemberWithUsers[]> {
+        // Load relations
+        // Load registrations of these members
+        const ids = Formatter.uniqueArray(members.map(m => ('users' in m) ? undefined : m.id));
+        if (ids.length === 0) {
+            return members as MemberWithUsers[];
+        }
 
-        const [results] = await Database.select(query, [paymentId]);
-        const registrations: RegistrationWithMember[] = [];
+        const users = await User.select(
+            SQL.wildcard(User.table),
+            SQL.column(MemberUser.table, 'membersId'),
+        )
+            .join(
+                SQL.join(MemberUser.table)
+                    .where(
+                        SQL.parentColumn('id'),
+                        SQL.column('usersId'),
+                    ),
+            )
+            .where(SQL.column(MemberUser.table, 'membersId'), ids)
+            .fetch();
+
+        for (const member of members) {
+            if ('users' in member) {
+                // Was already loaded
+                continue;
+            }
+            // Add registrations
+            // Add users
+            const memberUsers = users.filter((u) => {
+                const memberId = u.rawSelectedRow?.[MemberUser.table]?.['membersId'];
+                if (memberId) {
+                    return memberId === member.id;
+                }
+                return false;
+            });
+            member.setManyRelation(Member.users, memberUsers);
+        }
 
-        // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
-        const registrationMemberRelation = new ManyToOneRelation(Member, 'member');
-        registrationMemberRelation.foreignKey = Member.registrations.foreignKey;
+        return members as MemberWithUsers[];
+    }
 
-        for (const row of results) {
-            const registration = Registration.fromRow(row[Registration.table]);
-            if (!registration) {
-                throw new Error('Expected registration in every row');
+    static unloadUsers(members: Member[]) {
+        for (const member of members) {
+            if ('users' in member) {
+                delete member.users;
             }
+        }
+    }
 
-            const foundMember = Member.fromRow(row[Member.table]);
-            if (!foundMember) {
-                throw new Error('Expected member in every row');
+    static unloadRegistrations(members: Member[]) {
+        for (const member of members) {
+            if ('registrations' in member) {
+                delete member.registrations;
             }
-
-            const _f = registration.setRelation(registrationMemberRelation, foundMember);
-            registrations.push(_f);
         }
+    }
 
-        return registrations;
+    /**
+     * Fetch all members with their corresponding (valid) registrations, users
+     */
+    static async loadRegistrationsAndUsers(members: Member[], withGroups?: false): Promise<MemberWithUsersAndRegistrations[]>;
+    static async loadRegistrationsAndUsers(members: Member[], withGroups: true): Promise<MemberWithUsersRegistrationsAndGroups[]>;
+    static async loadRegistrationsAndUsers(members: Member[], withGroups: boolean | undefined = true): Promise<MemberWithUsersAndRegistrations[] | MemberWithUsersRegistrationsAndGroups[]> {
+        await this.loadRegistrations(members, withGroups as true);
+        await this.loadUsers(members);
+        return members as MemberWithUsersAndRegistrations[];
     }
 
     /**
      * Fetch all members with their corresponding (valid) registrations, users
      */
-    static async getBlobByIds(...ids: string[]): Promise<MemberWithRegistrations[]> {
+    static async getBlobByIds(...ids: string[]): Promise<MemberWithUsersRegistrationsAndGroups[]> {
         if (ids.length == 0) {
             return [];
         }
-        let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()}, ${User.getDefaultSelect()}  from \`${Member.table}\`\n`;
-        query += `LEFT JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`canRegister\` = 1)\n`;
-        query += Member.users.joinQuery(Member.table, User.table) + '\n';
-
-        // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
-        query += `where \`${Member.table}\`.\`${Member.primary.name}\` IN (?)`;
-
-        const [results] = await Database.select(query, [ids]);
-        const members: MemberWithRegistrations[] = [];
-
-        // Load groups
-        const groupIds = results.map(r => r[Registration.table]?.groupId).filter(id => id) as string[];
-        const groups = await Group.getByIDs(...Formatter.uniqueArray(groupIds));
-
-        for (const row of results) {
-            const foundMember = Member.fromRow(row[Member.table]);
-            if (!foundMember) {
-                throw new Error('Expected member in every row');
-            }
-            const _f = foundMember
-                .setManyRelation(Member.registrations as unknown as OneToManyRelation<'registrations', Member, Registration & { group: Group }>, [])
-                .setManyRelation(Member.users, []);
 
-            // Seach if we already got this member?
-            const existingMember = members.find(m => m.id == _f.id);
+        const baseMembers = await this.getByIDs(...ids);
 
-            const member: MemberWithRegistrations = (existingMember ?? _f);
-            if (!existingMember) {
-                members.push(member);
-            }
-
-            // Check if we have a registration with a payment
-            const registration = Registration.fromRow(row[Registration.table]);
-            if (registration) {
-                // Check if we already have this registration
-                if (!member.registrations.find(r => r.id == registration.id)) {
-                    const g = groups.find(g => g.id == registration.groupId);
-                    if (!g) {
-                        throw new Error('Group not found');
-                    }
-                    if (g.deletedAt === null) {
-                        member.registrations.push(registration.setRelation(Registration.group, g));
-                    }
-                }
-            }
-
-            // Check if we have a user
-            const user = User.fromRow(row[User.table]);
-            if (user) {
-                // Check if we already have this registration
-                if (!member.users.find(r => r.id == user.id)) {
-                    member.users.push(user);
-                }
-            }
+        if (baseMembers.length === 0) {
+            return [];
         }
 
-        return members;
+        await this.loadRegistrationsAndUsers(baseMembers, true);
+        return baseMembers as MemberWithUsersRegistrationsAndGroups[];
     }
 
     /**
      * Fetch all members with their corresponding (valid) registrations and payment
      */
-    static async getFamilyWithRegistrations(id: string): Promise<MemberWithRegistrations[]> {
-        let query = `SELECT l2.membersId as id from _members_users l1\n`;
-        query += `JOIN _members_users l2 on l2.usersId = l1.usersId \n`;
-        query += `where l1.membersId = ? group by l2.membersId`;
+    static async getFamily(id: string): Promise<Member[]> {
+        const results = await SQL.select(
+            SQL.column('l2', 'membersId'),
+        )
+            .from('_members_users', 'l1')
+            .join(
+                SQL.join('_members_users', 'l2')
+                    .where(
+                        SQL.column('l2', 'usersId'),
+                        SQL.column('l1', 'usersId'),
+                    ),
+            )
+            .where(
+                SQL.column('l1', 'membersId'),
+                id,
+            )
+            .groupBy(SQL.column('l2', 'membersId'))
+            .fetch();
 
-        const [results] = await Database.select(query, [id]);
         const ids: string[] = [];
         for (const row of results) {
-            ids.push(row['l2']['id'] as string);
+            ids.push(row['l2']['membersId'] as string);
         }
 
         if (!ids.includes(id)) {
@@ -309,7 +408,16 @@ export class Member extends QueryableModel {
             ids.push(id);
         }
 
-        return await this.getBlobByIds(...ids);
+        return await this.getByIDs(...ids);
+    }
+
+    /**
+     * @deprecated Please avoid implicit relation loading and only load the rel
+     * Fetch all members with their corresponding (valid) registrations and payment
+     */
+    static async getFamilyWithRegistrations(id: string): Promise<MemberWithUsersRegistrationsAndGroups[]> {
+        const members = await this.getFamily(id);
+        return await this.loadRegistrationsAndUsers(members, true);
     }
 
     /**
@@ -317,28 +425,26 @@ export class Member extends QueryableModel {
      */
     static async getMemberIdsForUser(user: User): Promise<string[]> {
         const query = SQL
-            .select('id')
-            .from(Member.table)
-            .join(
-                SQL
-                    .leftJoin('_members_users')
-                    .where(
-                        SQL.column('_members_users', 'membersId'),
-                        SQL.column(Member.table, 'id'),
-                    ),
-            ).where(
-                SQL.column('_members_users', 'usersId'),
-                user.id,
-            );
+            .select('membersId')
+            .from('_members_users')
+            .where('usersId', user.id);
 
         const data = await query.fetch();
-        return Formatter.uniqueArray(data.map(r => r.members.id as string));
+        return Formatter.uniqueArray(data.map(r => r._members_users.membersId as string));
+    }
+
+    /**
+     * Fetch all members with their corresponding (valid) registrations or waiting lists and payments
+     */
+    static async getMembersForUser(user: User): Promise<Member[]> {
+        return this.getByIDs(...(await this.getMemberIdsForUser(user)));
     }
 
     /**
+     * @deprecated Use getMembersForUser and load relations as needed
      * Fetch all members with their corresponding (valid) registrations or waiting lists and payments
      */
-    static async getMembersWithRegistrationForUser(user: User): Promise<MemberWithRegistrations[]> {
+    static async getMembersWithRegistrationForUser(user: User): Promise<MemberWithUsersRegistrationsAndGroups[]> {
         return this.getBlobByIds(...(await this.getMemberIdsForUser(user)));
     }
 

package/src/models/Organization.ts

@@ -2,7 +2,7 @@ import { column, Database } from '@simonbackx/simple-database';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { I18n } from '@stamhoofd/backend-i18n';
 import { EmailInterfaceRecipient } from '@stamhoofd/email';
-import { QueryableModel } from '@stamhoofd/sql';
+import { ModelCache, QueryableModel } from '@stamhoofd/sql';
 import { Address, appToUri, Country, DNSRecordStatus, EmailTemplateType, Language, OrganizationEmail, OrganizationMetaData, OrganizationPrivateMetaData, Organization as OrganizationStruct, PaymentMethod, PaymentProvider, PrivatePaymentConfiguration, Recipient, Replacement, STPackageType, TransferSettings } from '@stamhoofd/structures';
 
 import { CreateEmailIdentityCommand, DeleteEmailIdentityCommand, GetEmailIdentityCommand, GetEmailIdentityCommandOutput, PutEmailIdentityFeedbackAttributesCommand, PutEmailIdentityMailFromAttributesCommand, SESv2Client } from '@aws-sdk/client-sesv2';
@@ -18,6 +18,7 @@ import { OrganizationRegistrationPeriod, StripeAccount } from './index.js';
 
 export class Organization extends QueryableModel {
     static table = 'organizations';
+    // static cache = new ModelCache<Organization>();
 
     @column({
         primary: true, type: 'string', beforeSave(value) {