@stamhoofd/backend 2.15.0 → 2.17.0

package/src/helpers/FileCache.ts

@@ -0,0 +1,158 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { Formatter } from '@stamhoofd/utility';
+import basex from "base-x";
+import crypto from "crypto";
+import fs from 'node:fs';
+import { Writable } from 'node:stream';
+import { Readable } from 'stream';
+
+const ALPHABET = '0123456789abcdefghijklmnopqrstuvwxyz'
+const baseEncoder = basex(ALPHABET)
+
+async function randomBytes(size: number): Promise<Buffer> {
+    return new Promise((resolve, reject) => {
+        crypto.randomBytes(size, (err: Error | null, buf: Buffer) => {
+            if (err) {
+                reject(err);
+                return;
+            }
+            resolve(buf);
+        });
+    });
+}
+
+
+export class FileCache {
+    static async getWriteStream(extension: '.xlsx'): Promise<{
+        file: string,
+        stream: WritableStream
+    }> {
+        if (!STAMHOOFD.CACHE_PATH) {
+            throw new SimpleError({
+                code: "not_configured",
+                message: "CACHE_PATH environment variable is not configured",
+                statusCode: 500
+            })
+        }
+
+        // Generate a long and unguessable filename
+        const fileName = baseEncoder.encode(await randomBytes(100)).toLowerCase() + extension;
+        const path = Formatter.dateIso(new Date());
+
+        // Save in folder with the current day
+        // Since this contains the day, we can easily restrict access to files after 1 day
+        const folder = STAMHOOFD.CACHE_PATH + "/" + path;
+        await fs.promises.mkdir(folder, { recursive: true })
+
+        const s = fs.createWriteStream(folder + '/' + fileName, 'binary');
+
+        s.on('close', () => {
+            console.log('FileCache closed file: File written to disk', folder + '/' + fileName)
+        });
+
+        return {
+            file: path + '/' + fileName,
+            stream: Writable.toWeb(s)
+        }
+    }
+
+    static async read(file: string, dayTimeout = 1): Promise<{stream: Readable, contentLength: number, extension: string}> {
+        const splitted = file.split("/");
+        if (splitted.length != 2) {
+            throw new SimpleError({
+                code: "invalid_file",
+                message: "Invalid file",
+                human: "Ongeldig bestand",
+                statusCode: 400
+            })
+        }
+
+        const fileName = splitted[1];
+
+        const extension = fileName.substring(fileName.length - 5);
+        if (extension != '.xlsx') {
+            throw new SimpleError({
+                code: "invalid_file",
+                message: "Invalid file",
+                human: "Ongeldig bestand",
+                statusCode: 400
+            })
+        }
+
+        const fileNameWithoutExtension = fileName.substring(0, fileName.length - 5);
+
+        // Verify filename alphabet matching ALPHABET
+        for (const char of fileNameWithoutExtension) {
+            if (!ALPHABET.includes(char)) {
+                throw new SimpleError({
+                    code: "invalid_file",
+                    message: "Invalid file",
+                    human: "Onbekend karakters in bestandsnaam",
+                    statusCode: 400
+                })
+            }
+        }
+
+        const path = splitted[0];
+
+        // Verify date
+        if (path.length != 10) {
+            throw new SimpleError({
+                code: "invalid_file",
+                message: "Invalid file",
+                human: "Ongelidge datum",
+                statusCode: 400
+            })
+        }
+        const year = parseInt(path.substring(0, 4));
+        const month = parseInt(path.substring(5,  5 + 2));
+        const day = parseInt(path.substring(8, 8 + 2));
+
+        if (isNaN(year) || isNaN(month) || isNaN(day)) {
+            throw new SimpleError({
+                code: "invalid_file",
+                message: "Invalid file",
+                human: "Ongeldige datum",
+                statusCode: 400
+            })
+        }
+
+        const date = new Date(year, month - 1, day, 0, 0, 0);
+        const now = new Date();
+        now.setHours(0, 0, 0, 0);
+
+        const diff = now.getTime() - date.getTime()
+
+        if (date > now || diff > dayTimeout * 24 * 60 * 60 * 1000) {
+            throw new SimpleError({
+                code: "file_expired",
+                message: "File expired",
+                human: "Het bestand is verlopen",
+                statusCode: 404
+            })
+        }
+
+        const filePath = STAMHOOFD.CACHE_PATH + "/" + Formatter.dateIso(date) + "/" + fileName;
+
+        let stat: fs.Stats;
+        try {
+            stat = await fs.promises.stat(filePath);
+        } catch (e) {
+            if (e.code == 'ENOENT') {
+                throw new SimpleError({
+                    code: "file_expired",
+                    message: "File expired",
+                    human: "Het bestand bestaat niet",
+                    statusCode: 404
+                })
+            }
+            throw e;
+        }
+
+        return {
+            stream: fs.createReadStream(filePath),
+            contentLength: stat.size,
+            extension
+        }
+    }
+}

package/src/helpers/fetchToAsyncIterator.ts

@@ -0,0 +1,34 @@
+import { EncodableObject } from "@simonbackx/simple-encoding";
+import { LimitedFilteredRequest, PaginatedResponse } from "@stamhoofd/structures";
+
+export function fetchToAsyncIterator<T extends EncodableObject>(
+    initialFilter: LimitedFilteredRequest, 
+    loader: {
+        fetch(request: LimitedFilteredRequest): Promise<PaginatedResponse<T, LimitedFilteredRequest>>
+    }
+): AsyncIterable<T> {
+    return {
+        [Symbol.asyncIterator]: function () {
+            let request: LimitedFilteredRequest|null = initialFilter
+
+            return {
+                async next(): Promise<IteratorResult<T, undefined>> {
+                    if (!request) {
+                        return {
+                            done: true,
+                            value: undefined
+                        }
+                    }
+
+                    const response = await loader.fetch(request);
+                    request = response.next ?? null;
+                    
+                    return {
+                        done: false,
+                        value: response.results
+                    }
+                }
+            }
+        }
+    }
+}

package/src/sql-filters/balance-item-payments.ts

@@ -0,0 +1,13 @@
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace } from "@stamhoofd/sql";
+
+export 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')),
+    })
+}

package/src/sql-filters/members.ts

@@ -0,0 +1,179 @@
+import { SQL, SQLAge, SQLConcat, SQLFilterDefinitions, SQLScalar, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from "@stamhoofd/sql";
+import { Formatter } from "@stamhoofd/utility";
+import { organizationFilterCompilers } from "./organizations";
+import { registrationFilterCompilers } from "./registrations";
+
+/**
+ * Defines how to filter members in the database from StamhoofdFilter objects
+ */
+export const memberFilterCompilers: 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
+    ),
+}

package/src/sql-filters/organizations.ts

@@ -0,0 +1,115 @@
+import { SQL, SQLConcat, SQLFilterDefinitions, SQLNow, SQLNull, SQLScalar, SQLWhereEqual, SQLWhereOr, SQLWhereSign, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLRelationFilterCompiler } from "@stamhoofd/sql";
+
+export const organizationFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createSQLExpressionFilterCompiler(
+        SQL.column('organizations', 'id')
+    ),
+    uri: createSQLExpressionFilterCompiler(
+        SQL.column('organizations', 'uri')
+    ),
+    name: createSQLExpressionFilterCompiler(
+        SQL.column('organizations', 'name')
+    ),
+    active: createSQLExpressionFilterCompiler(
+        SQL.column('organizations', 'active')
+    ),
+    city: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.city'),
+        {isJSONValue: true}
+    ),
+    country: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('organizations', 'address'), '$.value.country'),
+        {isJSONValue: true}
+    ),
+    umbrellaOrganization: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.umbrellaOrganization'),
+        {isJSONValue: true}
+    ),
+    type: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.type'),
+        {isJSONValue: true}
+    ),
+    tags: createSQLExpressionFilterCompiler(
+        SQL.jsonValue(SQL.column('organizations', 'meta'), '$.value.tags'),
+        {isJSONValue: true, isJSONObject: true}
+    ),
+    packages: createSQLRelationFilterCompiler(
+        SQL.select().from(
+            SQL.table('stamhoofd_packages')
+        ).where(
+            SQL.column('organizationId'),
+            SQL.column('organizations', 'id'),
+        )
+        .where(
+            SQL.column('validAt'),
+            SQLWhereSign.NotEqual,
+            new SQLNull()
+        ).where(
+            new SQLWhereOr([
+                new SQLWhereEqual(
+                    SQL.column('validUntil'),
+                    SQLWhereSign.Equal,
+                    new SQLNull()
+                ),
+                new SQLWhereEqual(
+                    SQL.column('validUntil'),
+                    SQLWhereSign.Greater,
+                    new SQLNow()
+                )
+            ])
+        ).where(
+            new SQLWhereOr([
+                new SQLWhereEqual(
+                    SQL.column('removeAt'),
+                    SQLWhereSign.Equal,
+                    new SQLNull()
+                ),
+                new SQLWhereEqual(
+                    SQL.column('removeAt'),
+                    SQLWhereSign.Greater,
+                    new SQLNow()
+                )
+            ])
+        ),
+
+        // const pack1 = await STPackage.where({ organizationId, validAt: { sign: "!=", value: null }, removeAt: { sign: ">", value: new Date() }})
+        // const pack2 = await STPackage.where({ organizationId, validAt: { sign: "!=", value: null }, removeAt: null })
+        {
+            ...baseSQLFilterCompilers,
+            "type": createSQLExpressionFilterCompiler(
+                SQL.jsonValue(SQL.column('meta'), '$.value.type'),
+                {isJSONValue: true}
+            )
+        }
+    ),
+    members: createSQLRelationFilterCompiler(
+        SQL.select().from(
+            SQL.table('members')
+        ).join(
+            SQL.join(
+                SQL.table('registrations')
+            ).where(
+                SQL.column('members', 'id'),
+                SQL.column('registrations', 'memberId')
+            )
+        ).where(
+            SQL.column('registrations', 'organizationId'),
+            SQL.column('organizations', 'id'),
+        ),
+
+        {
+            ...baseSQLFilterCompilers,
+            name: createSQLExpressionFilterCompiler(
+                new SQLConcat(
+                    SQL.column('firstName'),
+                    new SQLScalar(' '),
+                    SQL.column('lastName'),
+                )
+            ),
+            "firstName": createSQLColumnFilterCompiler('firstName'),
+            "lastName": createSQLColumnFilterCompiler('lastName'),
+            "email": createSQLColumnFilterCompiler('email')
+        }
+    ),
+}

package/src/sql-filters/payments.ts

@@ -0,0 +1,78 @@
+import { SQL, SQLCast, SQLConcat, SQLFilterDefinitions, SQLJsonUnquote, SQLScalar, baseSQLFilterCompilers, createSQLColumnFilterCompiler, createSQLExpressionFilterCompiler, createSQLFilterNamespace, createSQLRelationFilterCompiler } from "@stamhoofd/sql";
+import { balanceItemPaymentsCompilers } from "./balance-item-payments";
+
+/**
+ * Defines how to filter members in the database from StamhoofdFilter objects
+ */
+export const paymentFilterCompilers: 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
+    ),
+}

package/src/sql-filters/registrations.ts

@@ -0,0 +1,24 @@
+import { SQLFilterDefinitions, baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQL, createSQLFilterNamespace, createSQLExpressionFilterCompiler } from "@stamhoofd/sql";
+
+export 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}),
+    })
+}

package/src/sql-sorters/members.ts

@@ -0,0 +1,46 @@
+import { MemberWithRegistrations } from "@stamhoofd/models"
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from "@stamhoofd/sql"
+import { Formatter } from "@stamhoofd/utility"
+
+export const memberSorters: 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
+}