@stamhoofd/backend 2.39.1 → 2.40.1

package/src/decoders/StringArrayDecoder.ts

@@ -1,4 +1,4 @@
-import { Data, Decoder } from "@simonbackx/simple-encoding";
+import { Data, Decoder } from '@simonbackx/simple-encoding';
 
 export class StringArrayDecoder<T> implements Decoder<T[]> {
     decoder: Decoder<T>;
@@ -11,14 +11,14 @@ export class StringArrayDecoder<T> implements Decoder<T[]> {
         const strValue = data.string;
 
         // Split on comma
-        const parts = strValue.split(",");
+        const parts = strValue.split(',');
         return parts
             .map((v, index) => {
-                return data.clone({ 
-                    data: v, 
-                    context: data.context, 
-                    field: data.addToCurrentField(index) 
-                }).decode(this.decoder)
+                return data.clone({
+                    data: v,
+                    context: data.context,
+                    field: data.addToCurrentField(index),
+                }).decode(this.decoder);
             });
     }
 }

package/src/decoders/StringNullableDecoder.ts

@@ -1,4 +1,4 @@
-import { Decoder, Data } from "@simonbackx/simple-encoding";
+import { Decoder, Data } from '@simonbackx/simple-encoding';
 
 export class StringNullableDecoder<T> implements Decoder<T | null> {
     decoder: Decoder<T>;
@@ -15,4 +15,3 @@ export class StringNullableDecoder<T> implements Decoder<T | null> {
         return data.decode(this.decoder);
     }
 }
-

package/src/email-recipient-loaders/members.ts

@@ -1,61 +1,61 @@
-import { Email } from "@stamhoofd/models";
-import { SQL } from "@stamhoofd/sql";
-import { EmailRecipientFilterType, LimitedFilteredRequest, PaginatedResponse, mergeFilters } from "@stamhoofd/structures";
-import { GetMembersEndpoint } from "../endpoints/global/members/GetMembersEndpoint";
+import { Email } from '@stamhoofd/models';
+import { SQL } from '@stamhoofd/sql';
+import { EmailRecipientFilterType, LimitedFilteredRequest, PaginatedResponse, mergeFilters } from '@stamhoofd/structures';
+import { GetMembersEndpoint } from '../endpoints/global/members/GetMembersEndpoint';
 
 Email.recipientLoaders.set(EmailRecipientFilterType.Members, {
     fetch: async (query: LimitedFilteredRequest) => {
-        const result = await GetMembersEndpoint.buildData(query)
+        const result = await GetMembersEndpoint.buildData(query);
 
         return new PaginatedResponse({
             results: result.results.members.flatMap(m => m.getEmailRecipients(['member'])),
-            next: result.next
+            next: result.next,
         });
     },
 
     count: async (query: LimitedFilteredRequest) => {
         query.filter = mergeFilters([query.filter, {
-            'email': {
-                $neq: null
-            }
-        }])
-        const q = await GetMembersEndpoint.buildQuery(query)
+            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)
+        const result = await GetMembersEndpoint.buildData(query);
 
         return new PaginatedResponse({
             results: result.results.members.flatMap(m => m.getEmailRecipients(['parents'])),
-            next: result.next
+            next: result.next,
         });
     },
 
     count: async (query: LimitedFilteredRequest) => {
-        const q = await GetMembersEndpoint.buildQuery(query)
+        const q = await GetMembersEndpoint.buildQuery(query);
         return await q.sum(
-            SQL.jsonLength(SQL.column('details'), '$.value.parents[*].email')
+            SQL.jsonLength(SQL.column('details'), '$.value.parents[*].email'),
         );
-    }
+    },
 });
 
 Email.recipientLoaders.set(EmailRecipientFilterType.MemberUnverified, {
     fetch: async (query: LimitedFilteredRequest) => {
-        const result = await GetMembersEndpoint.buildData(query)
+        const result = await GetMembersEndpoint.buildData(query);
 
         return new PaginatedResponse({
             results: result.results.members.flatMap(m => m.getEmailRecipients(['unverified'])),
-            next: result.next
+            next: result.next,
         });
     },
 
     count: async (query: LimitedFilteredRequest) => {
-        const q = await GetMembersEndpoint.buildQuery(query)
+        const q = await GetMembersEndpoint.buildQuery(query);
         return await q.sum(
-            SQL.jsonLength(SQL.column('details'), '$.value.unverifiedEmails')
+            SQL.jsonLength(SQL.column('details'), '$.value.unverifiedEmails'),
         );
-    }
+    },
 });

package/src/endpoints/admin/memberships/ChargeMembershipsEndpoint.ts

@@ -4,7 +4,6 @@ import { QueueHandler } from '@stamhoofd/queues';
 import { Context } from '../../../helpers/Context';
 import { MembershipCharger } from '../../../helpers/MembershipCharger';
 
-
 type Params = Record<string, never>;
 type Query = Record<string, never>;
 type Body = undefined;
@@ -12,11 +11,11 @@ type ResponseBody = undefined;
 
 export class ChargeMembershipsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/admin/charge-memberships", {});
+        const params = Endpoint.parseParameters(request.url, '/admin/charge-memberships', {});
 
         if (params) {
             return [true, params as Params];
@@ -25,24 +24,24 @@ export class ChargeMembershipsEndpoint extends Endpoint<Params, Query, Body, Res
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!Context.auth.hasPlatformFullAccess()) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         if (QueueHandler.isRunning('charge-memberships')) {
             throw new SimpleError({
                 code: 'charge_pending',
                 message: 'Charge already pending',
-                human: 'Er is al een aanrekening bezig, even geduld.'
-            })
+                human: 'Er is al een aanrekening bezig, even geduld.',
+            });
         }
 
         QueueHandler.schedule('charge-memberships', async () => {
-            await MembershipCharger.charge()
+            await MembershipCharger.charge();
         }).catch(console.error);
-       
+
         return new Response(undefined);
     }
 }

package/src/endpoints/admin/memberships/GetChargeMembershipsSummaryEndpoint.ts

@@ -6,7 +6,6 @@ import { QueueHandler } from '@stamhoofd/queues';
 import { Platform } from '@stamhoofd/models';
 import { SimpleError } from '@simonbackx/simple-errors';
 
-
 type Params = Record<string, never>;
 type Query = Record<string, never>;
 type Body = undefined;
@@ -14,11 +13,11 @@ type ResponseBody = ChargeMembershipsSummary;
 
 export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/admin/charge-memberships/summary", {});
+        const params = Endpoint.parseParameters(request.url, '/admin/charge-memberships/summary', {});
 
         if (params) {
             return [true, params as Params];
@@ -27,60 +26,60 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
+        await Context.authenticate();
 
         if (!Context.auth.hasPlatformFullAccess()) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         if (QueueHandler.isRunning('charge-memberships')) {
             return new Response(
                 ChargeMembershipsSummary.create({
-                    running: true
-                })
+                    running: true,
+                }),
             );
         }
-        
-        const platform = await Platform.getShared()
-        const chargeVia = platform.membershipOrganizationId
+
+        const platform = await Platform.getShared();
+        const chargeVia = platform.membershipOrganizationId;
 
         const query = SQL
             .select(
                 new SQLSelectAs(
                     new SQLCount(
                         new SQLDistinct(
-                            SQL.column('member_platform_memberships', 'id')
-                        )
+                            SQL.column('member_platform_memberships', 'id'),
+                        ),
                     ),
-                    new SQLAlias('data__memberships')
+                    new SQLAlias('data__memberships'),
                 ),
                 new SQLSelectAs(
                     new SQLCount(
                         new SQLDistinct(
-                            SQL.column('member_platform_memberships', 'memberId')
-                        )
+                            SQL.column('member_platform_memberships', 'memberId'),
+                        ),
                     ),
-                    new SQLAlias('data__members')
+                    new SQLAlias('data__members'),
                 ),
                 new SQLSelectAs(
                     new SQLCount(
                         new SQLDistinct(
-                            SQL.column('member_platform_memberships', 'organizationId')
-                        )
+                            SQL.column('member_platform_memberships', 'organizationId'),
+                        ),
                     ),
-                    new SQLAlias('data__organizations')
+                    new SQLAlias('data__organizations'),
                 ),
                 new SQLSelectAs(
                     new SQLSum(
-                        SQL.column('member_platform_memberships', 'price')
+                        SQL.column('member_platform_memberships', 'price'),
                     ),
-                    new SQLAlias('data__price')
-                )
+                    new SQLAlias('data__price'),
+                ),
             )
             .from('member_platform_memberships')
             .where('balanceItemId', null)
             .where('deletedAt', null)
-            .whereNot('organizationId', chargeVia)
+            .whereNot('organizationId', chargeVia);
 
         const result = await query.fetch();
         const members = result[0]['data']['members'] as number;
@@ -95,52 +94,52 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
                 members: members ?? 0,
                 price: price ?? 0,
                 organizations: organizations ?? 0,
-                membershipsPerType: await this.fetchPerType(chargeVia)
-            })
+                membershipsPerType: await this.fetchPerType(chargeVia),
+            }),
         );
     }
 
-    async fetchPerType(chargeVia: string|null) {
+    async fetchPerType(chargeVia: string | null) {
         const query = SQL
             .select(
                 SQL.column('member_platform_memberships', 'membershipTypeId'),
                 new SQLSelectAs(
                     new SQLCount(
                         new SQLDistinct(
-                            SQL.column('member_platform_memberships', 'id')
-                        )
+                            SQL.column('member_platform_memberships', 'id'),
+                        ),
                     ),
-                    new SQLAlias('data__memberships')
+                    new SQLAlias('data__memberships'),
                 ),
                 new SQLSelectAs(
                     new SQLCount(
                         new SQLDistinct(
-                            SQL.column('member_platform_memberships', 'memberId')
-                        )
+                            SQL.column('member_platform_memberships', 'memberId'),
+                        ),
                     ),
-                    new SQLAlias('data__members')
+                    new SQLAlias('data__members'),
                 ),
                 new SQLSelectAs(
                     new SQLCount(
                         new SQLDistinct(
-                            SQL.column('member_platform_memberships', 'organizationId')
-                        )
+                            SQL.column('member_platform_memberships', 'organizationId'),
+                        ),
                     ),
-                    new SQLAlias('data__organizations')
+                    new SQLAlias('data__organizations'),
                 ),
                 new SQLSelectAs(
                     new SQLSum(
-                        SQL.column('member_platform_memberships', 'price')
+                        SQL.column('member_platform_memberships', 'price'),
                     ),
-                    new SQLAlias('data__price')
-                )
+                    new SQLAlias('data__price'),
+                ),
             )
             .from('member_platform_memberships')
             .where('balanceItemId', null)
             .where('deletedAt', null)
             .whereNot('organizationId', chargeVia)
             .groupBy(
-                SQL.column('member_platform_memberships', 'membershipTypeId')
+                SQL.column('member_platform_memberships', 'membershipTypeId'),
             );
 
         const result = await query.fetch();
@@ -151,7 +150,7 @@ export class GetChargeMembershipsSummaryEndpoint extends Endpoint<Params, Query,
                 memberships: row['data']['memberships'] as number,
                 members: row['data']['members'] as number,
                 price: row['data']['price'] as number,
-                organizations: row['data']['organizations'] as number
+                organizations: row['data']['organizations'] as number,
             }));
         }
 

package/src/endpoints/admin/organizations/GetOrganizationsCountEndpoint.ts

@@ -11,14 +11,14 @@ type Body = undefined;
 type ResponseBody = CountResponse;
 
 export class GetOrganizationsCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/admin/organizations/count", {});
+        const params = Endpoint.parseParameters(request.url, '/admin/organizations/count', {});
 
         if (params) {
             return [true, params as Params];
@@ -27,16 +27,16 @@ export class GetOrganizationsCountEndpoint extends Endpoint<Params, Query, Body,
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
-        const query = GetOrganizationsEndpoint.buildQuery(request.query)
-        
+        await Context.authenticate();
+        const query = GetOrganizationsEndpoint.buildQuery(request.query);
+
         const count = await query
             .count();
 
         return new Response(
             CountResponse.create({
-                count
-            })
+                count,
+            }),
         );
     }
 }

package/src/endpoints/admin/organizations/GetOrganizationsEndpoint.ts

@@ -1,9 +1,8 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Organization } from '@stamhoofd/models';
-import { SQL, compileToSQLFilter, compileToSQLSorter } from "@stamhoofd/sql";
+import { SQL, compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
 import { CountFilteredRequest, LimitedFilteredRequest, Organization as OrganizationStruct, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -14,20 +13,20 @@ import { organizationSorters } from '../../../sql-sorters/organizations';
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = PaginatedResponse<OrganizationStruct[], LimitedFilteredRequest>
+type ResponseBody = PaginatedResponse<OrganizationStruct[], LimitedFilteredRequest>;
 
-const sorters = organizationSorters
-const filterCompilers = organizationFilterCompilers
+const sorters = organizationSorters;
+const filterCompilers = organizationFilterCompilers;
 
 export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/admin/organizations", {});
+        const params = Endpoint.parseParameters(request.url, '/admin/organizations', {});
 
         if (params) {
             return [true, params as Params];
@@ -35,69 +34,69 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
-    static buildQuery(q: CountFilteredRequest|LimitedFilteredRequest) {
-        const tags = Context.auth.getPlatformAccessibleOrganizationTags(PermissionLevel.Read)
-        if (tags != 'all' && tags.length === 0) {
-            throw Context.auth.error()
+    static buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const tags = Context.auth.getPlatformAccessibleOrganizationTags(PermissionLevel.Read);
+        if (tags !== 'all' && tags.length === 0) {
+            throw Context.auth.error();
         }
 
-        let scopeFilter: StamhoofdFilter|undefined = undefined;
+        let scopeFilter: StamhoofdFilter | undefined = undefined;
 
         if (tags !== 'all') {
             // Add organization scope filter
             scopeFilter = {
                 tags: {
-                    $in: tags
-                }
+                    $in: tags,
+                },
             };
         }
-        
+
         const query = SQL
             .select(
-                SQL.wildcard('organizations')
+                SQL.wildcard('organizations'),
             )
             .from(
-                SQL.table('organizations')
+                SQL.table('organizations'),
             );
-            
+
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers))
+            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
         }
 
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers))
+            query.where(compileToSQLFilter(q.filter, filterCompilers));
         }
 
         if (q.search) {
-            let searchFilter: StamhoofdFilter|null = null
+            let searchFilter: StamhoofdFilter | null = null;
 
             // todo: auto detect e-mailaddresses and search on admins
             searchFilter = {
                 name: {
-                    $contains: q.search
-                }
-            }
+                    $contains: q.search,
+                },
+            };
 
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers))
+                query.where(compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
 
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
+                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
             }
 
-            q.sort = assertSort(q.sort, [{key: 'id'}])
-            query.orderBy(compileToSQLSorter(q.sort, sorters))
-            query.limit(q.limit)
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            query.orderBy(compileToSQLSorter(q.sort, sorters));
+            query.limit(q.limit);
         }
-       
-        return query
+
+        return query;
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
+        await Context.authenticate();
 
         const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
 
@@ -105,22 +104,22 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
-                message: 'Limit can not be more than ' + maxLimit
-            })
+                message: 'Limit can not be more than ' + maxLimit,
+            });
         }
 
         if (request.query.limit < 1) {
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
-                message: 'Limit can not be less than 1'
-            })
+                message: 'Limit can not be less than 1',
+            });
         }
-        
-        const data = await GetOrganizationsEndpoint.buildQuery(request.query).fetch()
+
+        const data = await GetOrganizationsEndpoint.buildQuery(request.query).fetch();
         const organizations = Organization.fromRows(data, 'organizations');
 
-        let next: LimitedFilteredRequest|undefined;
+        let next: LimitedFilteredRequest | undefined;
 
         if (organizations.length >= request.query.limit) {
             const lastObject = organizations[organizations.length - 1];
@@ -131,8 +130,8 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
                 pageFilter: nextFilter,
                 sort: request.query.sort,
                 limit: request.query.limit,
-                search: request.query.search
-            })
+                search: request.query.search,
+            });
 
             if (JSON.stringify(nextFilter) === JSON.stringify(request.query.pageFilter)) {
                 console.error('Found infinite loading loop for', request.query);
@@ -142,9 +141,9 @@ export class GetOrganizationsEndpoint extends Endpoint<Params, Query, Body, Resp
 
         return new Response(
             new PaginatedResponse<OrganizationStruct[], LimitedFilteredRequest>({
-                results: await AuthenticatedStructures.adminOrganizations(organizations),
-                next
-            })
+                results: await AuthenticatedStructures.organizations(organizations),
+                next,
+            }),
         );
     }
 }