@stamhoofd/backend 2.7.0 → 2.9.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.7.0",
+    "version": "2.9.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",
@@ -50,5 +50,5 @@
         "postmark": "4.0.2",
         "stripe": "^16.6.0"
     },
-    "gitHead": "319a4de9fac39a31110cddbfa9a580d1b9c8f730"
+    "gitHead": "d1959fa457e81e41797c4f7fe216095505f50aeb"
 }

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')
     ),
@@ -160,6 +163,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/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

@@ -252,37 +252,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(