@stamhoofd/backend 2.8.0 → 2.13.0

package/.env.template.json

@@ -22,6 +22,7 @@
         "rendererApi": "renderer.stamhoofd"
     },
     "translationNamespace": "stamhoofd",
+    "platformName": "stamhoofd",
     "userMode": "organization",
     
     "PORT": 9091,
@@ -59,5 +60,6 @@
 
     "NOLT_SSO_SECRET_KEY": "",
     "INTERNAL_SECRET_KEY": "",
-    "CRONS_DISABLED": false
+    "CRONS_DISABLED": false,
+    "WHITELISTED_EMAIL_DESTINATIONS": ["*"]
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.8.0",
+    "version": "2.13.0",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -9,7 +9,7 @@
     },
     "license": "UNLICENCED",
     "scripts": {
-        "dev": "concurrently -r \"rm -rf ./dist && wait-on ./dist/index.js && nodemon --quiet --inspect=5858 --watch dist --delay 200ms --exec node --enable-source-maps ./dist/index.js --signal SIGTERM\" 'yarn build --watch --preserveWatchOutput'",
+        "dev": "echo 'Waiting for shared backend packages...' && wait-on ../../shared/env/dist/index.js && echo 'Start building backend API' && concurrently -r 'yarn build --watch --preserveWatchOutput' \"wait-on ./dist/index.js && nodemon --quiet --inspect=5858 --watch dist --watch '../../../shared/*/dist/' --watch '../../shared/*/dist/' --ext .ts,.json,.sql,.js --watch .env.json --delay 1000ms --exec 'node --enable-source-maps ./dist/index.js' --signal SIGTERM\"",
         "dev:backend": "yarn dev",
         "build": "rm -rf ./dist/src/migrations && rm -rf ./dist/src/seeds && tsc -b",
         "build:full": "yarn clear && yarn build",
@@ -35,6 +35,14 @@
         "@simonbackx/simple-database": "1.24.0",
         "@simonbackx/simple-endpoints": "1.13.0",
         "@simonbackx/simple-logging": "^1.0.1",
+        "@stamhoofd/backend-i18n": "^2.13.0",
+        "@stamhoofd/backend-middleware": "^2.13.0",
+        "@stamhoofd/email": "^2.13.0",
+        "@stamhoofd/models": "^2.13.0",
+        "@stamhoofd/queues": "^2.13.0",
+        "@stamhoofd/sql": "^2.13.0",
+        "@stamhoofd/structures": "^2.13.0",
+        "@stamhoofd/utility": "^2.13.0",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
         "cookie": "^0.5.0",
@@ -50,5 +58,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "1e0e1853f8dea6b47718433b2890907042c17ddc"
+    "gitHead": "2b130616eebea8cd30feb0f361c7bb0f48b534ba"
 }

package/src/crons.ts

@@ -140,7 +140,7 @@ async function checkWebshopDNS() {
 }
 
 async function checkReplies() {
-    if (STAMHOOFD.environment === "development") {
+    if (STAMHOOFD.environment !== "production") {
         return;
     }
 
@@ -200,7 +200,7 @@ async function checkReplies() {
 let lastPostmarkCheck: Date | null = null
 let lastPostmarkId: string | null = null
 async function checkPostmarkBounces() {
-    if (STAMHOOFD.environment === "development") {
+    if (STAMHOOFD.environment !== "production") {
         return;
     }
     
@@ -842,4 +842,4 @@ export const crons = async () => {
         }
     }
     schedulingJobs = false;
-};
+};

package/src/decoders/StringArrayDecoder.ts

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

package/src/decoders/StringNullableDecoder.ts

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

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

@@ -19,6 +19,9 @@ export const filterCompilers: SQLFilterDefinitions = {
     id: createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'id')
     ),
+    uri: createSQLExpressionFilterCompiler(
+        SQL.column('organizations', 'uri')
+    ),
     name: createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'name')
     ),
@@ -27,33 +30,23 @@ export const filterCompilers: SQLFilterDefinitions = {
     ),
     city: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
     country: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.country'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
     umbrellaOrganization: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.umbrellaOrganization'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
     type: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.type'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
     tags: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.tags'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     ),
     packages: createSQLRelationFilterCompiler(
         SQL.select().from(
@@ -100,9 +93,7 @@ export const filterCompilers: SQLFilterDefinitions = {
             ...baseSQLFilterCompilers,
             "type": createSQLExpressionFilterCompiler(
                 SQL.jsonValue(SQL.column('meta'), '$.value.type'),
-                undefined,
-                true,
-                false
+                {isJSONValue: true}
             )
         }
     ),
@@ -160,6 +151,17 @@ const sorters: SQLSortDefinitions<Organization> = {
             })
         }
     },
+    'uri': {
+        getValue(a) {
+            return a.uri
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('uri'),
+                direction
+            })
+        }
+    },
     'type': {
         getValue(a) {
             return a.meta.type

package/src/endpoints/global/email/PatchEmailEndpoint.ts

@@ -100,6 +100,7 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
         }
 
         if (request.body.status === EmailStatus.Sending || request.body.status === EmailStatus.Sent) {
+            model.throwIfNotReadyToSend()
             model.send().catch(console.error)
         }
 

package/src/endpoints/global/events/GetEventsEndpoint.ts

@@ -24,21 +24,15 @@ const filterCompilers: SQLFilterDefinitions = {
     endDate: createSQLColumnFilterCompiler('endDate'),
     groupIds: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.groups[*].id'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     ),
     defaultAgeGroupIds: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     ),
     organizationTagIds: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('meta'), '$.value.organizationTagIds'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     )
 }
 

package/src/endpoints/global/events/PatchEventsEndpoint.ts

@@ -1,7 +1,7 @@
 import { AutoEncoderPatchType, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, patchObject, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { Event, Group, Organization, Platform, RegistrationPeriod } from '@stamhoofd/models';
-import { Event as EventStruct, GroupType, PermissionLevel } from "@stamhoofd/structures";
+import { Event as EventStruct, GroupType, NamedObject, PermissionLevel } from "@stamhoofd/structures";
 
 import { SimpleError } from '@simonbackx/simple-errors';
 import { SQL, SQLWhereSign } from '@stamhoofd/sql';
@@ -81,6 +81,7 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.endDate = put.endDate
             event.meta = put.meta
             event.typeId = await PatchEventsEndpoint.validateEventType(put.typeId)
+            event.meta.organizationCache = eventOrganization ? NamedObject.create({id: eventOrganization.id, name: eventOrganization.name}) : null
             await PatchEventsEndpoint.checkEventLimits(event)
 
             if (!(await Context.auth.canAccessEvent(event, PermissionLevel.Full))) {
@@ -128,6 +129,16 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.name = patch.name ?? event.name
             event.startDate = patch.startDate ?? event.startDate
             event.endDate = patch.endDate ?? event.endDate
+
+            if (patch.meta?.organizationCache) {
+                throw new SimpleError({
+                    code: 'invalid_field',
+                    message: 'Cannot patch organizationCache',
+                    human: 'Je kan de organizationCache niet aanpassen via een patch',
+                    field: 'meta.organizationCache'
+                })
+            }
+
             event.meta = patchObject(event.meta, patch.meta)
 
             if (patch.organizationId !== undefined) {
@@ -156,6 +167,15 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                     })
                 }
                 event.organizationId = patch.organizationId
+                event.meta.organizationCache = eventOrganization ? NamedObject.create({id: eventOrganization.id, name: eventOrganization.name}) : null
+            } else {
+                // Update cache
+                if (event.organizationId) {
+                    const eventOrganization = await Organization.getByID(event.organizationId)
+                    if (eventOrganization) {
+                        event.meta.organizationCache = NamedObject.create({id: eventOrganization.id, name: eventOrganization.name})
+                    }
+                }
             }
 
             event.typeId = patch.typeId ? (await PatchEventsEndpoint.validateEventType(patch.typeId)) : event.typeId

package/src/endpoints/global/groups/GetGroupsEndpoint.ts

@@ -0,0 +1,79 @@
+import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { Group, Organization } from '@stamhoofd/models';
+import { GroupsWithOrganizations } from "@stamhoofd/structures";
+
+import { AutoEncoder, Decoder, field, StringDecoder } from "@simonbackx/simple-encoding";
+import { Formatter } from "@stamhoofd/utility";
+import { StringArrayDecoder } from "../../../decoders/StringArrayDecoder";
+import { AuthenticatedStructures } from "../../../helpers/AuthenticatedStructures";
+import { Context } from "../../../helpers/Context";
+import { SimpleError } from "@simonbackx/simple-errors";
+type Params = Record<string, never>;
+
+class Query extends AutoEncoder {
+    @field({ decoder: new StringArrayDecoder(StringDecoder) })
+    ids: string[]
+
+    /**
+     * List of organizations the requester already knows and doesn't need to be included in the response
+     */
+    @field({ decoder: new StringArrayDecoder(StringDecoder), optional: true })
+    excludeOrganizationIds: string[] = []
+}
+
+type Body = undefined
+type ResponseBody = GroupsWithOrganizations
+
+/**
+ * Get the members of the user
+ */
+export class GetGroupsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = Query as Decoder<Query>
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method != "GET") {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, "/groups", {});
+
+        if (params) {
+            return [true, params as Params];
+        }
+
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        await Context.setOptionalOrganizationScope();
+        await Context.optionalAuthenticate()
+
+        if (request.query.ids.length === 0) {
+            return new Response(
+                GroupsWithOrganizations.create({
+                    groups: [],
+                    organizations: []
+                })
+            );
+        }
+
+        if (request.query.ids.length > 100) {
+            throw new SimpleError({
+                code: "too_many_ids",
+                message: "You can't request more than 100 groups at once"
+            })
+        }
+
+        const groups = await Group.getByIDs(...request.query.ids)
+        const organizationIds = Formatter.uniqueArray(groups.map(g => g.organizationId).filter(id => !request.query.excludeOrganizationIds.includes(id)));
+
+        const organizations = organizationIds.length > 0 ? (await Organization.getByIDs(...organizationIds)) : [];
+        
+        return new Response(
+            GroupsWithOrganizations.create({
+                groups: await AuthenticatedStructures.groups(groups),
+                organizations: await AuthenticatedStructures.organizations(organizations)
+            })
+        );
+    }
+}

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

@@ -75,25 +75,12 @@ Email.recipientLoaders.set(EmailRecipientFilterType.MemberUnverified, {
 
 const registrationFilterCompilers: SQLFilterDefinitions = {
     ...baseSQLFilterCompilers,
-    "price": createSQLColumnFilterCompiler('price'),
+    "price": createSQLColumnFilterCompiler('price', {nullable: true}),
     "pricePaid": createSQLColumnFilterCompiler('pricePaid'),
-    "waitingList": createSQLColumnFilterCompiler('waitingList'),
     "canRegister": createSQLColumnFilterCompiler('canRegister'),
-    "cycle": createSQLColumnFilterCompiler('cycle'),
-
-    "cycleOffset": createSQLExpressionFilterCompiler({
-        getSQL(options) {
-            return joinSQLQuery([
-                SQL.column('groups', 'cycle').getSQL(options),
-                ' - ',
-                SQL.column('registrations', 'cycle').getSQL(options)
-            ])
-        },
-    }),
-
     "organizationId": createSQLColumnFilterCompiler('organizationId'),
     "groupId": createSQLColumnFilterCompiler('groupId'),
-    "registeredAt": createSQLColumnFilterCompiler('registeredAt'),
+    "registeredAt": createSQLColumnFilterCompiler('registeredAt', {nullable: true}),
     "periodId": createSQLColumnFilterCompiler(SQL.column('registrations', 'periodId')),
 
     "group": createSQLFilterNamespace({
@@ -105,7 +92,7 @@ const registrationFilterCompilers: SQLFilterDefinitions = {
         status: createSQLExpressionFilterCompiler(
             SQL.column('groups', 'status')
         ),
-        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId')),
+        defaultAgeGroupId: createSQLColumnFilterCompiler(SQL.column('groups', 'defaultAgeGroupId'), {nullable: true}),
     })
 }
 
@@ -120,20 +107,21 @@ const filterCompilers: SQLFilterDefinitions = {
         )
     ),
     age: createSQLExpressionFilterCompiler(
-        new SQLAge(SQL.column('birthDay'))
+        new SQLAge(SQL.column('birthDay')), 
+        {nullable: true}
     ),
     gender: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.gender'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
-    birthDay: createSQLColumnFilterCompiler('birthDay', (d) => {
-        if (typeof d === 'number') {
-            const date = new Date(d)
-            return Formatter.dateIso(date);
+    birthDay: createSQLColumnFilterCompiler('birthDay', {
+        normalizeValue: (d) => {
+            if (typeof d === 'number') {
+                const date = new Date(d)
+                return Formatter.dateIso(date);
+            }
+            return d;
         }
-        return d;
     }),
     organizationName: createSQLExpressionFilterCompiler(
         SQL.column('organizations', 'name')
@@ -141,16 +129,12 @@ const filterCompilers: SQLFilterDefinitions = {
 
     email: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.email'),
-        undefined,
-        true,
-        false
+        {isJSONValue: true}
     ),
 
     parentEmail: createSQLExpressionFilterCompiler(
         SQL.jsonValue(SQL.column('details'), '$.value.parents[*].email'),
-        undefined,
-        true,
-        true
+        {isJSONValue: true, isJSONObject: true}
     ),
 
     registrations: createSQLRelationFilterCompiler(
@@ -252,37 +236,6 @@ const filterCompilers: SQLFilterDefinitions = {
         }
     ),
 
-    /**
-     * @deprecated?
-     */
-    activeRegistrations: createSQLRelationFilterCompiler(
-        SQL.select()
-        .from(
-            SQL.table('registrations')
-        ).join(
-            SQL.join(
-                SQL.table('groups')
-            ).where(
-                SQL.column('groups', 'id'),
-                SQL.column('registrations', 'groupId')
-            )
-        )
-        .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
-    ),
-
     organizations: createSQLRelationFilterCompiler(
         SQL.select()
         .from(

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

@@ -2,8 +2,8 @@ import { OneToManyRelation } from '@simonbackx/simple-database';
 import { ConvertArrayToPatchableArray, Decoder, PatchableArrayAutoEncoder, PatchableArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { SimpleError } from "@simonbackx/simple-errors";
-import { BalanceItem, BalanceItemPayment, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Payment, Platform, Registration, RegistrationPeriod, User } from '@stamhoofd/models';
-import { BalanceItemStatus, MemberWithRegistrationsBlob, MembersBlob, PaymentMethod, PaymentStatus, PermissionLevel, Registration as RegistrationStruct, User as UserStruct } from "@stamhoofd/structures";
+import { BalanceItem, Document, Group, Member, MemberFactory, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, Platform, Registration, User } from '@stamhoofd/models';
+import { MemberWithRegistrationsBlob, MembersBlob, PermissionLevel } from "@stamhoofd/structures";
 import { Formatter } from '@stamhoofd/utility';
 
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';

package/src/endpoints/global/registration/GetUserBalanceEndpoint.ts

@@ -1,13 +1,13 @@
 import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
 import { BalanceItem, Member } from "@stamhoofd/models";
-import { MemberBalanceItem } from "@stamhoofd/structures";
+import { BalanceItemWithPayments } from "@stamhoofd/structures";
 
 import { Context } from "../../../helpers/Context";
 
 type Params = Record<string, never>;
 type Query = undefined
 type Body = undefined
-type ResponseBody = MemberBalanceItem[]
+type ResponseBody = BalanceItemWithPayments[]
 
 export class GetUserBalanceEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
@@ -33,7 +33,7 @@ export class GetUserBalanceEndpoint extends Endpoint<Params, Query, Body, Respon
         const balanceItems = await BalanceItem.balanceItemsForUsersAndMembers(organization?.id ?? null, [user.id], members.map(m => m.id))
 
         return new Response(
-            await BalanceItem.getMemberStructure(balanceItems)
+            await BalanceItem.getStructureWithPayments(balanceItems)
         );
     }
 }