@stamhoofd/backend 2.120.6 → 2.121.0

package/src/sql-filters/groups.ts

@@ -1,4 +1,4 @@
-import type { SQLFilterDefinitions} from '@stamhoofd/sql';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
 import { baseSQLFilterCompilers, createColumnFilter, createWildcardColumnFilter, SQL, SQLJsonExtract, SQLValueType } from '@stamhoofd/sql';
 import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
 
@@ -34,6 +34,16 @@ export const groupFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    type: createColumnFilter({
+        expression: SQL.column('type'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    waitingListId: createColumnFilter({
+        expression: SQL.column('waitingListId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     bundleDiscounts: createWildcardColumnFilter(
         (key: string) => ({
             expression: SQL.jsonExtract(SQL.column('settings'), `$.value.prices[*].bundleDiscounts.${SQLJsonExtract.escapePathComponent(key)}`, true),

package/src/sql-filters/payments.ts

@@ -38,6 +38,11 @@ export const paymentFilterCompilers: SQLFilterDefinitions = {
         type: SQLValueType.String,
         nullable: true,
     }),
+    invoiceId: createColumnFilter({
+        expression: SQL.column('invoiceId'),
+        type: SQLValueType.String,
+        nullable: true,
+    }),
     createdAt: createColumnFilter({
         expression: SQL.column('createdAt'),
         type: SQLValueType.Datetime,

package/src/sql-filters/registration-invitations.ts

@@ -0,0 +1,90 @@
+import { Group, Member, Organization, RegistrationInvitation } from '@stamhoofd/models';
+import type { SQLFilterDefinitions } from '@stamhoofd/sql';
+import { baseSQLFilterCompilers, createColumnFilter, createJoinedRelationFilter, SQL, SQLValueType } from '@stamhoofd/sql';
+import { SQLTranslatedString } from '../helpers/SQLTranslatedString.js';
+import { memberFilterCompilers } from './members.js';
+
+export const memberJoin = SQL.join(Member.table).where(SQL.column(Member.table, 'id'), SQL.column(RegistrationInvitation.table, 'memberId'));
+
+export const groupJoin = SQL.join(Group.table).where(SQL.column(Group.table, 'id'), SQL.column(RegistrationInvitation.table, 'groupId'));
+
+export const organizationJoin = SQL.join(Organization.table).where(SQL.column(Organization.table, 'id'), SQL.column(RegistrationInvitation.table, 'organizationId'));
+
+export const registrationInvitationFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    id: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'id'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    organizationId: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'organizationId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    groupId: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'groupId'),
+        type: SQLValueType.String,
+        nullable: false,
+        // todo?
+        // async checkPermission(filter) {
+        //     await checkGroupIdFilterAccess(filter, PermissionLevel.Read);
+        // },
+    }),
+    memberId: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'memberId'),
+        type: SQLValueType.String,
+        nullable: false,
+    }),
+    createdAt: createColumnFilter({
+        expression: SQL.column(RegistrationInvitation.table, 'createdAt'),
+        type: SQLValueType.Datetime,
+        nullable: false,
+    }),
+    member: createJoinedRelationFilter(
+        memberJoin,
+        memberFilterCompilers,
+    ),
+    group: createJoinedRelationFilter(
+        groupJoin,
+        {
+            ...baseSQLFilterCompilers,
+            id: createColumnFilter({
+                expression: SQL.column('groupId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            periodId: createColumnFilter({
+                expression: SQL.column('periodId'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            type: createColumnFilter({
+                expression: SQL.column('groups', 'type'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            name: createColumnFilter({
+                expression: new SQLTranslatedString(SQL.column('groups', 'settings'), '$.value.name'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            status: createColumnFilter({
+                expression: SQL.column('groups', 'status'),
+                type: SQLValueType.String,
+                nullable: false,
+            }),
+            defaultAgeGroupId: createColumnFilter({
+                expression: SQL.column('groups', 'defaultAgeGroupId'),
+                type: SQLValueType.String,
+                nullable: true,
+            }),
+            // temporary keep filter for testing
+            deletedAt: createColumnFilter({
+                expression: SQL.column('groups', 'deletedAt'),
+                type: SQLValueType.Datetime,
+                nullable: true,
+            }),
+        },
+    ),
+};

package/src/sql-sorters/registration-invitations.ts

@@ -0,0 +1,36 @@
+import type { RegistrationInvitation } from '@stamhoofd/models';
+import type { SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { SQL, SQLOrderBy } from '@stamhoofd/sql';
+
+export const registrationInvitationSorters: SQLSortDefinitions<RegistrationInvitation> = {
+    // WARNING! TEST NEW SORTERS THOROUGHLY!
+    // Try to avoid creating sorters on fields that er not 1:1 with the database, that often causes pagination issues if not thought through
+    // An example: sorting on 'name' is not a good idea, because it is a concatenation of two fields.
+    // You might be tempted to use ORDER BY firstName, lastName, but that will not work as expected and it needs to be ORDER BY CONCAT(firstName, ' ', lastName)
+    // Why? Because ORDER BY firstName, lastName produces a different order dan ORDER BY CONCAT(firstName, ' ', lastName) if there are multiple people with spaces in the first name
+    // And that again causes issues with pagination because the next query will append a filter of name > 'John Doe' - causing duplicate and/or skipped results
+    // What if you need mapping? simply map the sorters in the frontend: name -> firstname, lastname, age -> birthDay, etc.
+
+    'id': {
+        getValue(invitation) {
+            return invitation.id;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction,
+            });
+        },
+    },
+    'createdAt': {
+        getValue(invitation) {
+            return invitation.createdAt;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
+};

package/vitest.config.js

@@ -8,6 +8,7 @@ export default defineConfig({
         globals: true,
         root: import.meta.dirname,
         isolate: true,
+        testTimeout: 10_000, // required for slow CI
         maxWorkers: 1, // For now we can't run parallel because all test files use the same database
     },
 });

package/src/endpoints/global/billing/ActivatePackagesEndpoint.ts

@@ -1,216 +0,0 @@
-import type { Decoder } from '@simonbackx/simple-encoding';
-import type { DecodedRequest, Request} from '@simonbackx/simple-endpoints';
-import { Endpoint, Response } from '@simonbackx/simple-endpoints';
-import { SimpleError } from '@simonbackx/simple-errors';
-import type { BalanceItem} from '@stamhoofd/models';
-import { Organization, Platform, STPackage } from '@stamhoofd/models';
-import { CheckoutResponse, PackageCheckout, Payment as PaymentStruct, STPackageBundleHelper, STPackageStruct } from '@stamhoofd/structures';
-import { Context } from '../../../helpers/Context.js';
-import { PaymentService } from '../../../services/PaymentService.js';
-import { STPackageService } from '../../../services/STPackageService.js';
-
-type Params = Record<string, never>;
-type Query = undefined;
-type Body = PackageCheckout;
-type ResponseBody = CheckoutResponse;
-
-export class ActivatePackagesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = PackageCheckout as Decoder<Body>;
-
-    protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method !== 'POST') {
-            return [false];
-        }
-
-        const params = Endpoint.parseParameters(request.url, '/billing/activate-packages', {});
-
-        if (params) {
-            return [true, params as Params];
-        }
-        return [false];
-    }
-
-    async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope();
-        const { user } = await Context.authenticate();
-
-        // If the user has permission, we'll also search if he has access to the organization's key
-        if (!await Context.auth.canActivatePackages(organization.id)) {
-            throw Context.auth.error();
-        }
-        const checkout = request.body;
-
-        // Validate company
-        if (checkout.customer && checkout.customer.company) {
-            // Search company id
-            // this avoids needing to check the VAT number every time
-            const id = checkout.customer.company.id;
-            const foundCompany = organization.meta.companies.find(c => c.id === id);
-
-            if (!foundCompany) {
-                throw new SimpleError({
-                    code: 'invalid_data',
-                    message: $t(`%w1`),
-                });
-            }
-        }
-
-        const currentPackages = await STPackageService.getActivePackages(organization.id);
-
-        const packages: STPackageStruct[] = [];
-        const balanceItems: Map<BalanceItem, number> = new Map();
-        const models: STPackage[] = [];
-        let totalPrice = 0;
-
-        if (STAMHOOFD.userMode === 'organization') {
-            // Only allowed in organization mode
-            for (const bundle of request.body.purchases.packageBundles) {
-            // Renew after currently running packages
-                let date = new Date();
-
-                let skip = false;
-
-                // Do we have a collision? Make sure our package only start after the expiry date of existing packages
-                for (const currentPack of currentPackages) {
-                    if (!STPackageBundleHelper.isCombineable(bundle, STPackageStruct.create(currentPack))) {
-                        if (!STPackageBundleHelper.isStackable(bundle, STPackageStruct.create(currentPack))) {
-                        // WE skip silently
-                            console.error('Tried to activate non combineable, non stackable packages...');
-                            skip = true;
-                            continue;
-                        }
-                        if (currentPack.validUntil !== null) {
-                            const end = currentPack.validUntil;
-                            if (end > date) {
-                                date = end;
-                            }
-                        }
-                    }
-                }
-
-                if (skip) {
-                    continue;
-                }
-                packages.push(STPackageBundleHelper.getCurrentPackage(bundle, date));
-            }
-
-            // Add renewals
-            if (checkout.purchases.renewPackageIds.length > 0) {
-                for (const id of checkout.purchases.renewPackageIds) {
-                    const pack = currentPackages.find(c => c.id === id);
-                    if (!pack) {
-                        throw new SimpleError({
-                            code: 'not_found',
-                            message: 'Package not found',
-                            human: $t('%1L1'),
-                        });
-                    }
-
-                    // Renew
-                    const model = pack.createRenewed();
-
-                    const balanceItem = await STPackageService.chargePackage(model, undefined, checkout.customer ?? undefined);
-                    if (balanceItem) {
-                        totalPrice += balanceItem.priceWithVAT;
-                        balanceItems.set(balanceItem, balanceItem.priceWithVAT);
-                    }
-
-                    if (!request.body.proForma) {
-                        await model.save();
-                        await balanceItem?.save();
-                    }
-                    models.push(model);
-                }
-            }
-        }
-
-        // Create the real models for each package
-        // calculate the price for these packages and create a hidden balance item
-        for (const pack of packages) {
-            const model = new STPackage();
-            model.id = pack.id;
-            model.meta = pack.meta;
-            model.validUntil = pack.validUntil;
-            model.removeAt = pack.removeAt;
-
-            // Not yet valid / active (ignored until valid)
-            model.validAt = null;
-            model.organizationId = organization.id;
-
-            const balanceItem = await STPackageService.chargePackage(model, undefined, checkout.customer ?? undefined);
-            if (balanceItem) {
-                totalPrice += balanceItem.priceWithVAT;
-                balanceItems.set(balanceItem, balanceItem.priceWithVAT);
-            }
-
-            if (!request.body.proForma) {
-                await model.save();
-                await balanceItem?.save();
-            }
-
-            models.push(model);
-        }
-
-        // todo: Add pending items (balance items in request)
-
-        const membershipOrganizationId = (await Platform.getShared()).membershipOrganizationId;
-        if (!membershipOrganizationId) {
-            throw new SimpleError({
-                code: 'unavailable',
-                message: 'No membership organization id set on the platform',
-                human: 'Package purchases are currently unavailable',
-            });
-        }
-
-        const membershipOrganization = await Organization.getByID(membershipOrganizationId);
-        if (!membershipOrganization) {
-            throw new Error('Unexpected missing membershipOrganization');
-        }
-
-        const result = await PaymentService.createPayment({
-            balanceItems,
-            checkout,
-            user,
-            organization: membershipOrganization,
-            payingOrganization: organization,
-            serviceFeeType: 'system',
-        });
-
-        console.log('Created payment', result);
-
-        if (!result) {
-            // No payment needed
-            throw new SimpleError({
-                code: 'missing_data',
-                message: 'Checkout was empty',
-                human: $t('%1L2'),
-            });
-        }
-
-        if (!checkout.proForma) {
-            for (const pack of models) {
-                await pack.save();
-            }
-        }
-        else {
-            // Delete payment again
-            if (result) {
-                await result.payment.delete();
-                result.paymentUrl = null;
-                result.paymentQRCode = null;
-            }
-
-            for (const [item] of balanceItems) {
-                await item.delete();
-            }
-        }
-
-        const { payment, paymentUrl, paymentQRCode } = result;
-
-        return new Response(CheckoutResponse.create({
-            payment: payment ? PaymentStruct.create(payment) : null,
-            paymentUrl,
-            paymentQRCode,
-        }));
-    }
-}