@stamhoofd/backend 2.14.0 → 2.16.0

package/src/endpoints/global/members/GetMembersEndpoint.ts

@@ -2,314 +2,23 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { Email, Member, MemberWithRegistrations, Platform } from '@stamhoofd/models';
-import { SQL, SQLAge, SQLConcat, SQLFilterDefinitions, SQLOrderBy, SQLOrderByDirection, SQLScalar, SQLSortDefinitions, baseSQLFilterCompilers, compileToSQLFilter, compileToSQLSorter, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler, joinSQLQuery } from "@stamhoofd/sql";
-import { CountFilteredRequest, EmailRecipientFilterType, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, getSortFilter, mergeFilters } from '@stamhoofd/structures';
-import { DataValidator, Formatter } from '@stamhoofd/utility';
+import { Member, Platform } from '@stamhoofd/models';
+import { SQL, compileToSQLFilter, compileToSQLSorter } from "@stamhoofd/sql";
+import { CountFilteredRequest, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, getSortFilter } from '@stamhoofd/structures';
+import { DataValidator } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../helpers/Context';
-import { filterCompilers as organizationFilterCompilers } from '../../admin/organizations/GetOrganizationsEndpoint';
+import { memberFilterCompilers } from '../../../sql-filters/members';
+import { memberSorters } from '../../../sql-sorters/members';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<MembersBlob, LimitedFilteredRequest>
 
-Email.recipientLoaders.set(EmailRecipientFilterType.Members, {
-    fetch: async (query: LimitedFilteredRequest) => {
-        const result = await GetMembersEndpoint.buildData(query)
-
-        return new PaginatedResponse({
-            results: result.results.members.flatMap(m => m.getEmailRecipients(['member'])),
-            next: result.next
-        });
-    },
-
-    count: async (query: LimitedFilteredRequest) => {
-        query.filter = mergeFilters([query.filter, {
-            'email': {
-                $neq: null
-            }
-        }])
-        const q = await GetMembersEndpoint.buildQuery(query)
-        return await q.count();
-    }
-});
-
-Email.recipientLoaders.set(EmailRecipientFilterType.MemberParents, {
-    fetch: async (query: LimitedFilteredRequest) => {
-        const result = await GetMembersEndpoint.buildData(query)
-
-        return new PaginatedResponse({
-            results: result.results.members.flatMap(m => m.getEmailRecipients(['parents'])),
-            next: result.next
-        });
-    },
-
-    count: async (query: LimitedFilteredRequest) => {
-        const q = await GetMembersEndpoint.buildQuery(query)
-        return await q.sum(
-            SQL.jsonLength(SQL.column('details'), '$.value.parents[*].email')
-        );
-    }
-});
-
-Email.recipientLoaders.set(EmailRecipientFilterType.MemberUnverified, {
-    fetch: async (query: LimitedFilteredRequest) => {
-        const result = await GetMembersEndpoint.buildData(query)
-
-        return new PaginatedResponse({
-            results: result.results.members.flatMap(m => m.getEmailRecipients(['unverified'])),
-            next: result.next
-        });
-    },
-
-    count: async (query: LimitedFilteredRequest) => {
-        const q = await GetMembersEndpoint.buildQuery(query)
-        return await q.sum(
-            SQL.jsonLength(SQL.column('details'), '$.value.unverifiedEmails')
-        );
-    }
-});
-
-const registrationFilterCompilers: SQLFilterDefinitions = {
-    ...baseSQLFilterCompilers,
-    "price": createSQLColumnFilterCompiler('price', {nullable: true}),
-    "pricePaid": createSQLColumnFilterCompiler('pricePaid'),
-    "canRegister": createSQLColumnFilterCompiler('canRegister'),
-    "organizationId": createSQLColumnFilterCompiler('organizationId'),
-    "groupId": createSQLColumnFilterCompiler('groupId'),
-    "registeredAt": createSQLColumnFilterCompiler('registeredAt', {nullable: true}),
-    "periodId": createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
-
-    "group": createSQLFilterNamespace({
-        ...baseSQLFilterCompilers,
-        id: createSQLColumnFilterCompiler('groupId'),
-        name: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('groups', 'settings'), '$.value.name')
-        ),
-        status: createSQLExpressionFilterCompiler(
-            SQL.column('groups', 'status')
-        ),
-        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), {nullable: true}),
-    })
-}
-
-const filterCompilers: SQLFilterDefinitions = {
-    ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    name: createSQLExpressionFilterCompiler(
-        new SQLConcat(
-            SQL.column('firstName'),
-            new SQLScalar(' '),
-            SQL.column('lastName'),
-        )
-    ),
-    age: createSQLExpressionFilterCompiler(
-        new SQLAge(SQL.column('birthDay')), 
-        {nullable: true}
-    ),
-    gender: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.gender'),
-        {isJSONValue: true}
-    ),
-    birthDay: createSQLColumnFilterCompiler('birthDay', {
-        normalizeValue: (d) => {
-            if (typeof d === 'number') {
-                const date = new Date(d)
-                return Formatter.dateIso(date);
-            }
-            return d;
-        }
-    }),
-    organizationName: createSQLExpressionFilterCompiler(
-        SQL.column('organizations', 'name')
-    ),
-
-    email: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.email'),
-        {isJSONValue: true}
-    ),
-
-    parentEmail: createSQLExpressionFilterCompiler(
-        SQL.jsonValue(SQL.column('details'), '$.value.parents[*].email'),
-        {isJSONValue: true, isJSONObject: true}
-    ),
-
-    registrations: createSQLRelationFilterCompiler(
-        SQL.select()
-        .from(
-            SQL.table('registrations')
-        ).join(
-            SQL.join(
-                SQL.table('groups')
-            ).where(
-                SQL.column('groups', 'id'),
-                SQL.column('registrations', 'groupId')
-            )
-        )
-        .join(
-            SQL.join(
-                SQL.table('organizations')
-            ).where(
-                SQL.column('organizations', 'id'),
-                SQL.column('registrations', 'organizationId')
-            )
-        )
-        .where(
-            SQL.column('memberId'),
-            SQL.column('members', 'id'),
-        ).whereNot(
-            SQL.column('registeredAt'),
-            null,
-        ).where(
-            SQL.column('deactivatedAt'),
-            null,
-        ).where(
-            SQL.column('groups', 'deletedAt'),
-            null
-        ),
-        {
-            ...registrationFilterCompilers,
-            "organization": createSQLFilterNamespace(organizationFilterCompilers)
-        }
-    ),
-
-    responsibilities: createSQLRelationFilterCompiler(
-        SQL.select()
-        .from(
-            SQL.table('member_responsibility_records')
-        )
-        .join(
-            SQL.leftJoin(
-                SQL.table('groups')
-            ).where(
-                SQL.column('groups', 'id'),
-                SQL.column('member_responsibility_records', 'groupId')
-            )
-        )
-        .where(
-            SQL.column('memberId'),
-            SQL.column('members', 'id'),
-        ),
-        {
-            ...baseSQLFilterCompilers,
-            // Alias for responsibilityId
-            "id": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
-            "responsibilityId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'responsibilityId')),
-            "organizationId": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'organizationId')),
-            "startDate": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'startDate')),
-            "endDate": createSQLColumnFilterCompiler(SQL.column('member_responsibility_records', 'endDate')),
-            "group": createSQLFilterNamespace({
-                ...baseSQLFilterCompilers,
-                id: createSQLColumnFilterCompiler(SQL.column('groups', 'id')),
-                defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId')),
-            })
-        }
-    ),
-
-    platformMemberships: createSQLRelationFilterCompiler(
-        SQL.select()
-        .from(
-            SQL.table('member_platform_memberships')
-        )
-        .where(
-            SQL.column('memberId'),
-            SQL.column('members', 'id'),
-        )
-        .where(
-            SQL.column('deletedAt'),
-            null,
-        ),
-        {
-            ...baseSQLFilterCompilers,
-            "id": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'id')),
-            "membershipTypeId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'membershipTypeId')),
-            "organizationId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'organizationId')),
-            "periodId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'periodId')),
-            "price": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'price')),
-            "invoiceId": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'invoiceId')),
-            "startDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'startDate')),
-            "endDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'endDate')),
-            "expireDate": createSQLColumnFilterCompiler(SQL.column('member_platform_memberships', 'expireDate')),
-        }
-    ),
-
-    organizations: createSQLRelationFilterCompiler(
-        SQL.select()
-        .from(
-            SQL.table('registrations')
-        ).join(
-            SQL.join(
-                SQL.table('groups')
-            ).where(
-                SQL.column('groups', 'id'),
-                SQL.column('registrations', 'groupId')
-            )
-        ).join(
-            SQL.join(
-                SQL.table('organizations')
-            ).where(
-                SQL.column('organizations', 'id'),
-                SQL.column('registrations', 'organizationId')
-            )
-        ).where(
-            SQL.column('memberId'),
-            SQL.column('members', 'id'),
-        ).whereNot(
-            SQL.column('registeredAt'),
-            null,
-        ).where(
-            SQL.column('groups', 'deletedAt'),
-            null
-        ),
-        organizationFilterCompilers
-    ),
-}
-
-const sorters: SQLSortDefinitions<MemberWithRegistrations> = {
-    'id': {
-        getValue(a) {
-            return a.id
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('id'),
-                direction
-            })
-        }
-    },
-    'name': {
-        getValue(a) {
-            return a.details.name
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return SQLOrderBy.combine([
-                new SQLOrderBy({
-                    column: SQL.column('firstName'),
-                    direction
-                }),
-                new SQLOrderBy({
-                    column: SQL.column('lastName'),
-                    direction
-                })
-            ])
-        }
-    },
-    'birthDay': {
-        getValue(a) {
-            return a.details.birthDay ? Formatter.dateIso(a.details.birthDay) : null
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('birthDay'),
-                direction
-            })
-        }
-    }
-    // Note: never add mapped sortings, that should happen in the frontend -> e.g. map age to birthDay
-}
+const sorters = memberSorters
+const filterCompilers = memberFilterCompilers
 
 export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
@@ -365,6 +74,10 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             // Add organization scope filter
             const groups = await Context.auth.getAccessibleGroups(organization.id)
 
+            if (groups.length === 0) {
+                throw Context.auth.error()
+            }
+
             if (groups === 'all') {
                 if (await Context.auth.hasFullAccess(organization.id)) {
                     // Can access full history for now

package/src/endpoints/organization/dashboard/email/EmailEndpoint.ts

@@ -196,9 +196,29 @@ export class EmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
 
         const email = request.body
 
+        if (!email.html) {
+            throw new SimpleError({
+                code: "missing_field",
+                message: "Missing html",
+                human: "Je hebt geen inhoud ingevuld voor je e-mail. Vul een bericht in en probeer opnieuw.",
+                field: "html"
+            })
+        }
+
+        if (!email.subject) {
+            throw new SimpleError({
+                code: "missing_field",
+                message: "Missing subject",
+                human: "Je hebt geen onderwerp ingevuld voor je e-mail. Vul een onderwerp in en probeer opnieuw.",
+                field: "subject"
+            })
+        }
+
         // Create e-mail builder
         const builder = await getEmailBuilder(organization, {
-            ...email,
+            subject: email.subject,
+            html: email.html,
+            recipients: email.recipients,
             from,
             replyTo,
             attachments,
@@ -218,7 +238,7 @@ export class EmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
         const builder2 = await getEmailBuilder(organization, {
             ...email,
             subject: "[KOPIE] "+email.subject,
-            html: email.html?.replace("<body>", "<body>"+prefix) ?? null,
+            html: email.html.replace("<body>", "<body>"+prefix),
             recipients: [
                 recipient
             ],

package/src/endpoints/organization/dashboard/payments/GetPaymentsEndpoint.ts

@@ -3,149 +3,21 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Payment } from '@stamhoofd/models';
-import { SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLOrderBy, SQLOrderByDirection, SQLScalar, SQLSortDefinitions, baseSQLFilterCompilers, compileToSQLFilter, compileToSQLSorter, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from "@stamhoofd/sql";
+import { SQL, compileToSQLFilter, compileToSQLSorter } from "@stamhoofd/sql";
 import { CountFilteredRequest, LimitedFilteredRequest, PaginatedResponse, PaymentGeneral, StamhoofdFilter, getSortFilter } from '@stamhoofd/structures';
-import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
+import { paymentFilterCompilers } from '../../../../sql-filters/payments';
+import { paymentSorters } from '../../../../sql-sorters/payments';
 
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
 type ResponseBody = PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>
 
-const balanceItemPaymentsCompilers: SQLFilterDefinitions = {
-    ...baseSQLFilterCompilers,
-    "id": createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'id')),
-    "price": createSQLColumnFilterCompiler(SQL.column('balance_item_payments', 'price')),
-    
-    "balanceItem": createSQLFilterNamespace({
-        ...baseSQLFilterCompilers,
-        id: createSQLColumnFilterCompiler(SQL.column('balance_items', 'id')),
-        description: createSQLColumnFilterCompiler(SQL.column('balance_items', 'description')),
-    })
-}
-
-const filterCompilers: SQLFilterDefinitions = {
-    ...baseSQLFilterCompilers,
-    id: createSQLColumnFilterCompiler('id'),
-    method: createSQLColumnFilterCompiler('method'),
-    status: createSQLColumnFilterCompiler('status'),
-    organizationId: createSQLColumnFilterCompiler('organizationId'),
-    createdAt: createSQLColumnFilterCompiler('createdAt'),
-    updatedAt: createSQLColumnFilterCompiler('updatedAt'),
-    paidAt: createSQLColumnFilterCompiler('paidAt', {nullable: true}),
-    price: createSQLColumnFilterCompiler('price'),
-    provider: createSQLColumnFilterCompiler('provider', {nullable: true}),
-    customer: createSQLFilterNamespace({
-        ...baseSQLFilterCompilers,
-        email: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('customer'), '$.value.email'),
-            {isJSONValue: true}
-        ),
-        firstName: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('customer'), '$.value.firstName'),
-            {isJSONValue: true}
-        ),
-        lastName: createSQLExpressionFilterCompiler(
-            SQL.jsonValue(SQL.column('customer'), '$.value.lastName'),
-            {isJSONValue: true}
-        ),
-        name: createSQLExpressionFilterCompiler(
-            new SQLCast(
-                new SQLConcat(
-                    new SQLJsonUnquote(SQL.jsonValue(SQL.column('customer'), '$.value.firstName')),
-                    new SQLScalar(' '),
-                    new SQLJsonUnquote(SQL.jsonValue(SQL.column('customer'), '$.value.lastName')),
-                ),
-                'CHAR'
-            )
-        ),
-        company: createSQLFilterNamespace({
-            name: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('customer'), '$.value.company.name'),
-                {isJSONValue: true}
-            ),
-            VATNumber: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('customer'), '$.value.company.VATNumber'),
-                {isJSONValue: true}
-            ),
-            companyNumber: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('customer'), '$.value.company.companyNumber'),
-                {isJSONValue: true}
-            ),
-            administrationEmail: createSQLExpressionFilterCompiler(
-                SQL.jsonValue(SQL.column('customer'), '$.value.company.administrationEmail'),
-                {isJSONValue: true}
-            ),
-        })
-    }),
-    balanceItemPayments: createSQLRelationFilterCompiler(
-        SQL.select()
-        .from(
-            SQL.table('balance_item_payments')
-        ).join(
-            SQL.join(
-                SQL.table('balance_items')
-            ).where(
-                SQL.column('balance_items', 'id'),
-                SQL.column('balance_item_payments', 'balanceItemId')
-            )
-        ).where(
-            SQL.column('paymentId'),
-            SQL.column('payments', 'id')
-        ),
-        balanceItemPaymentsCompilers
-    ),
-}
-
-const sorters: SQLSortDefinitions<Payment> = {
-    'id': {
-        getValue(a) {
-            return a.id
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('id'),
-                direction
-            })
-        }
-    },
-    'createdAt': {
-        getValue(a) {
-            return Formatter.dateTimeIso(a.createdAt, 'UTC')
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('createdAt'),
-                direction
-            })
-        }
-    },
-    'paidAt': {
-        getValue(a) {
-            return a.paidAt !== null ? Formatter.dateTimeIso(a.paidAt, 'UTC') : null
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('paidAt'),
-                direction
-            })
-        }
-    },
-    'price': {
-        getValue(a) {
-            return a.price
-        },
-        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
-            return new SQLOrderBy({
-                column: SQL.column('price'),
-                direction
-            })
-        }
-    }
-}
+const filterCompilers = paymentFilterCompilers
+const sorters = paymentSorters
 
 export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
@@ -296,7 +168,7 @@ export class GetPaymentsEndpoint extends Endpoint<Params, Query, Body, ResponseB
         }
 
         return new PaginatedResponse<PaymentGeneral[], LimitedFilteredRequest>({
-            results: await AuthenticatedStructures.paymentsGeneral(payments, false),
+            results: await AuthenticatedStructures.paymentsGeneral(payments, true),
             next
         });
     }

package/src/endpoints/organization/dashboard/webshops/GetWebshopOrdersEndpoint.ts

@@ -26,8 +26,10 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
+    async handle(_: DecodedRequest<Params, Query, Body>): Promise<Response<ResponseBody>> {
+        await Promise.resolve();
+        throw new Error('Not implemented');
+        /*const organization = await Context.setOrganizationScope();
         await Context.authenticate()
 
         // Fast throw first (more in depth checking for patches later)
@@ -78,6 +80,6 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
                     afterNumber: orders[orders.length - 1].number ?? undefined
                 }) : undefined
             })
-        );
+        );*/
     }
 }

package/src/endpoints/organization/dashboard/webshops/GetWebshopTicketsEndpoint.ts

@@ -26,8 +26,10 @@ export class GetWebshopTicketsEndpoint extends Endpoint<Params, Query, Body, Res
         return [false];
     }
 
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
+    async handle(_: DecodedRequest<Params, Query, Body>): Promise<Response<ResponseBody>> {
+        await Promise.resolve();
+        throw new Error('Not implemented');
+        /*const organization = await Context.setOrganizationScope();
         await Context.authenticate()
 
         // Fast throw first (more in depth checking for patches later)
@@ -63,6 +65,6 @@ export class GetWebshopTicketsEndpoint extends Endpoint<Params, Query, Body, Res
                     lastId: tickets[tickets.length - 1].id ?? undefined
                 }) : undefined
             })
-        );
+        );*/
     }
 }

package/src/excel-loaders/members.ts

@@ -0,0 +1,101 @@
+import { XlsxBuiltInNumberFormat } from "@stamhoofd/excel-writer";
+import { ExcelExportType, LimitedFilteredRequest, PaginatedResponse, MemberWithRegistrationsBlob, Platform } from "@stamhoofd/structures";
+import { ExportToExcelEndpoint } from "../endpoints/global/files/ExportToExcelEndpoint";
+import { GetMembersEndpoint } from "../endpoints/global/members/GetMembersEndpoint";
+import { Context } from "../helpers/Context";
+
+ExportToExcelEndpoint.loaders.set(ExcelExportType.Members, {
+    fetch: async (query: LimitedFilteredRequest) => {
+        const result = await GetMembersEndpoint.buildData(query)
+
+        return new PaginatedResponse({
+            results: result.results.members,
+            next: result.next
+        });
+    },
+    sheets: [
+        {
+            id: 'members',
+            name: 'Leden',
+            columns: [
+                {
+                    id: 'id',
+                    name: 'ID',
+                    width: 20,
+                    getValue: (object: MemberWithRegistrationsBlob) => ({
+                        value: object.id
+                    })
+                },
+                {
+                    id: 'firstName',
+                    name: 'Voornaam',
+                    width: 20,
+                    getValue: (object: MemberWithRegistrationsBlob) => ({
+                        value: object.details.firstName
+                    })
+                },
+                {
+                    id: 'lastName',
+                    name: 'Achternaam',
+                    width: 20,
+                    getValue: (object: MemberWithRegistrationsBlob) => ({
+                        value: object.details.lastName
+                    })
+                },
+                {
+                    id: 'birthDay',
+                    name: 'Geboortedatum',
+                    width: 20,
+                    getValue: (object: MemberWithRegistrationsBlob) => ({
+                        value: object.details.birthDay,
+                        style: {
+                            numberFormat: {
+                                id: XlsxBuiltInNumberFormat.DateSlash
+                            }
+                        }
+                    })
+                },
+
+                // Dynamic records
+                {
+                    match(id) {
+                        console.log('match', id)
+                        if (id.startsWith('recordAnswers.')) {
+                            const platform = Platform.shared
+                            const organization = Context.organization
+
+                            const recordSettings = [
+                                ...(organization?.meta.recordsConfiguration.recordCategories.flatMap(category => category.getAllRecords()) ?? []),
+                                ...platform.config.recordsConfiguration.recordCategories.flatMap(category => category.getAllRecords())
+                            ]
+
+                            const recordSettingId = id.split('.')[1];
+                            console.log('recordSettingId', recordSettingId)
+                            const recordSetting = recordSettings.find(r => r.id === recordSettingId)
+                            
+
+                            if (!recordSetting) {
+                                // Will throw a proper error itself
+                                console.log('recordSetting not found', recordSettings)
+                                return
+                            }
+
+                            const columns = recordSetting.excelColumns
+
+                            return columns.map((columnName, index) => {
+                                return {
+                                    id: `recordAnswers.${recordSettingId}.${index}`,
+                                    name: columnName,
+                                    width: 20,
+                                    getValue: (object: MemberWithRegistrationsBlob) => ({
+                                        value: object.details.recordAnswers.get(recordSettingId)?.excelValues[index]?.value ?? ''
+                                    })
+                                }
+                            })
+                        }
+                    },
+                }
+            ]
+        }
+    ]
+})