@stamhoofd/backend 2.43.1 → 2.43.3

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.43.1",
+    "version": "2.43.3",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -36,14 +36,14 @@
         "@simonbackx/simple-encoding": "2.15.1",
         "@simonbackx/simple-endpoints": "1.14.0",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.43.1",
-        "@stamhoofd/backend-middleware": "2.43.1",
-        "@stamhoofd/email": "2.43.1",
-        "@stamhoofd/models": "2.43.1",
-        "@stamhoofd/queues": "2.43.1",
-        "@stamhoofd/sql": "2.43.1",
-        "@stamhoofd/structures": "2.43.1",
-        "@stamhoofd/utility": "2.43.1",
+        "@stamhoofd/backend-i18n": "2.43.3",
+        "@stamhoofd/backend-middleware": "2.43.3",
+        "@stamhoofd/email": "2.43.3",
+        "@stamhoofd/models": "2.43.3",
+        "@stamhoofd/queues": "2.43.3",
+        "@stamhoofd/sql": "2.43.3",
+        "@stamhoofd/structures": "2.43.3",
+        "@stamhoofd/utility": "2.43.3",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -60,5 +60,5 @@
         "postmark": "^4.0.5",
         "stripe": "^16.6.0"
     },
-    "gitHead": "49f9a42eb52688f4f4d417871da7448969623013"
+    "gitHead": "1258338deacc6d61a53da939dda894dca3415c84"
 }

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

@@ -53,6 +53,11 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
             event.organizationId = put.organizationId;
             event.meta = put.meta;
 
+            if (event.organizationId === null && event.meta.groups !== null) {
+                event.meta.groups = null;
+                console.error('Removed groups because organizationId is null for new event');
+            }
+
             if (event.meta.groups && event.meta.groups.length === 0) {
                 throw new SimpleError({
                     code: 'invalid_field',
@@ -131,6 +136,11 @@ export class PatchEventsEndpoint extends Endpoint<Params, Query, Body, ResponseB
                 event.organizationId = patch.organizationId;
             }
 
+            if (event.organizationId === null && event.meta.groups !== null) {
+                event.meta.groups = null;
+                console.error('Removed groups because organizationId is null for event', event.id);
+            }
+
             if (event.meta.groups && event.meta.groups.length === 0) {
                 throw new SimpleError({
                     code: 'invalid_field',

package/src/endpoints/organization/dashboard/webshops/GetWebshopOrdersCountEndpoint.ts

@@ -0,0 +1,57 @@
+import { Decoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { CountFilteredRequest, CountResponse, PermissionLevel } from '@stamhoofd/structures';
+
+import { Webshop } from '@stamhoofd/models';
+import { Context } from '../../../../helpers/Context';
+import { GetWebshopOrdersEndpoint } from './GetWebshopOrdersEndpoint';
+
+type Params = { id: string };
+type Query = CountFilteredRequest;
+type Body = undefined;
+type ResponseBody = CountResponse;
+
+export class GetWebshopOrdersCountEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
+    queryDecoder = CountFilteredRequest as Decoder<CountFilteredRequest>;
+
+    protected doesMatch(request: Request): [true, Params] | [false] {
+        if (request.method !== 'GET') {
+            return [false];
+        }
+
+        const params = Endpoint.parseParameters(request.url, '/webshop/@id/orders/count', { id: String });
+
+        if (params) {
+            return [true, params as Params];
+        }
+        return [false];
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>) {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
+
+        // Fast throw first (more in depth checking for patches later)
+        if (!await Context.auth.hasSomeAccess(organization.id)) {
+            throw Context.auth.error();
+        }
+
+        const webshopId = request.params.id;
+
+        const webshop = await Webshop.getByID(webshopId);
+        if (!webshop || !await Context.auth.canAccessWebshop(webshop, PermissionLevel.Read)) {
+            throw Context.auth.notFoundOrNoAccess('Je hebt geen toegang tot de bestellingen van deze webshop');
+        }
+
+        const query = GetWebshopOrdersEndpoint.buildQuery(webshopId, request.query);
+
+        const count = await query
+            .count();
+
+        return new Response(
+            CountResponse.create({
+                count,
+            }),
+        );
+    }
+}

package/src/endpoints/organization/dashboard/webshops/GetWebshopOrdersEndpoint.ts

@@ -1,17 +1,25 @@
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
-import { Order, Webshop } from '@stamhoofd/models';
-import { PaginatedResponse, PermissionLevel, PrivateOrder, WebshopOrdersQuery } from '@stamhoofd/structures';
+import { assertSort, CountFilteredRequest, getSortFilter, LimitedFilteredRequest, PaginatedResponse, PermissionLevel, PrivateOrder, StamhoofdFilter } from '@stamhoofd/structures';
 
+import { Order, Webshop } from '@stamhoofd/models';
+import { compileToSQLFilter, compileToSQLSorter, SQL, SQLFilterDefinitions, SQLSortDefinitions } from '@stamhoofd/sql';
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
 import { Context } from '../../../../helpers/Context';
+import { LimitedFilteredRequestHelper } from '../../../../helpers/LimitedFilteredRequestHelper';
+import { orderFilterCompilers } from '../../../../sql-filters/orders';
+import { orderSorters } from '../../../../sql-sorters/orders';
 
 type Params = { id: string };
-type Query = WebshopOrdersQuery;
+type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = PaginatedResponse<PrivateOrder[], Query>;
+type ResponseBody = PaginatedResponse<PrivateOrder[], LimitedFilteredRequest>;
+
+const filterCompilers: SQLFilterDefinitions = orderFilterCompilers;
+const sorters: SQLSortDefinitions<Order> = orderSorters;
 
 export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = WebshopOrdersQuery as Decoder<WebshopOrdersQuery>;
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
         if (request.method !== 'GET') {
@@ -26,22 +34,124 @@ export class GetWebshopOrdersEndpoint extends Endpoint<Params, Query, Body, Resp
         return [false];
     }
 
-    async handle(_: DecodedRequest<Params, Query, Body>): Promise<Response<ResponseBody>> {
-        await Promise.resolve();
-        throw new Error('Not implemented');
-        /* const organization = await Context.setOrganizationScope();
-        await Context.authenticate()
+    static buildQuery(webshopId: string, q: CountFilteredRequest | LimitedFilteredRequest) {
+        // todo: filter userId???
+        const organization = Context.organization!;
+
+        if (!webshopId) {
+            // todo
+            throw new Error();
+        }
+
+        const ordersTable: string = Order.table;
+
+        const query = SQL
+            .select(SQL.wildcard(ordersTable))
+            .from(SQL.table(ordersTable))
+            // todo: extra check on webshopId to prevent all orders are returned if webshopId is null?
+            .where('webshopId', webshopId)
+            .where(compileToSQLFilter({
+                $or: [
+                    {
+                        organizationId: organization.id,
+                    },
+                    {
+                        organizationId: null,
+                    },
+                ],
+            }, filterCompilers));
+
+        if (q.filter) {
+            query.where(compileToSQLFilter(q.filter, filterCompilers));
+        }
+
+        if (q.search) {
+            let searchFilter: StamhoofdFilter | null = null;
+
+            // todo: detect special search patterns and adjust search filter if needed
+            searchFilter = {
+                name: {
+                    $contains: q.search,
+                },
+            };
+
+            if (searchFilter) {
+                query.where(compileToSQLFilter(searchFilter, filterCompilers));
+            }
+        }
+
+        if (q instanceof LimitedFilteredRequest) {
+            if (q.pageFilter) {
+                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
+            }
+
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            query.orderBy(compileToSQLSorter(q.sort, sorters));
+            query.limit(q.limit);
+        }
+
+        return query;
+    }
+
+    static async buildData(webshopId: string, requestQuery: LimitedFilteredRequest) {
+        const query = this.buildQuery(webshopId, requestQuery);
+        const data = await query.fetch();
+
+        const orders: Order[] = Order.fromRows(data, Order.table);
+
+        let next: LimitedFilteredRequest | undefined;
+
+        if (orders.length >= requestQuery.limit) {
+            const lastObject = orders[orders.length - 1];
+            const nextFilter = getSortFilter(lastObject, sorters, requestQuery.sort);
+
+            next = new LimitedFilteredRequest({
+                filter: requestQuery.filter,
+                pageFilter: nextFilter,
+                sort: requestQuery.sort,
+                limit: requestQuery.limit,
+                search: requestQuery.search,
+            });
+
+            if (JSON.stringify(nextFilter) === JSON.stringify(requestQuery.pageFilter)) {
+                console.error('Found infinite loading loop for', requestQuery);
+                next = undefined;
+            }
+        }
+
+        return new PaginatedResponse<PrivateOrder[], LimitedFilteredRequest>({
+            results: await AuthenticatedStructures.orders(orders),
+            next,
+        });
+    }
+
+    async handle(request: DecodedRequest<Params, Query, Body>): Promise<Response<ResponseBody>> {
+        const organization = await Context.setOrganizationScope();
+        await Context.authenticate();
 
         // Fast throw first (more in depth checking for patches later)
         if (!await Context.auth.hasSomeAccess(organization.id)) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
-        const webshop = await Webshop.getByID(request.params.id)
+        LimitedFilteredRequestHelper.throwIfInvalidLimit({
+            request: request.query,
+            maxLimit: Context.auth.hasSomePlatformAccess() ? 1000 : 100,
+        });
+
+        const webshopId = request.params.id;
+
+        const webshop = await Webshop.getByID(webshopId);
         if (!webshop || !await Context.auth.canAccessWebshop(webshop, PermissionLevel.Read)) {
-            throw Context.auth.notFoundOrNoAccess("Je hebt geen toegang tot de bestellingen van deze webshop")
+            throw Context.auth.notFoundOrNoAccess('Je hebt geen toegang tot de bestellingen van deze webshop');
         }
 
+        return new Response(
+            await GetWebshopOrdersEndpoint.buildData(webshopId, request.query),
+        );
+
+        /*
+
         let orders: Order[] | undefined = undefined
         const limit = 50
 

package/src/helpers/AuthenticatedStructures.ts

@@ -1,6 +1,6 @@
 import { SimpleError } from '@simonbackx/simple-errors';
-import { CachedOutstandingBalance, Event, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from '@stamhoofd/models';
-import { AccessRight, CachedOutstandingBalanceObject, CachedOutstandingBalanceObjectContact, CachedOutstandingBalance as CachedOutstandingBalanceStruct, CachedOutstandingBalanceType, Event as EventStruct, Group as GroupStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateWebshop, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
+import { CachedOutstandingBalance, Event, Group, Member, MemberPlatformMembership, MemberResponsibilityRecord, MemberWithRegistrations, Order, Organization, OrganizationRegistrationPeriod, Payment, RegistrationPeriod, User, Webshop } from '@stamhoofd/models';
+import { AccessRight, CachedOutstandingBalanceObject, CachedOutstandingBalanceObjectContact, CachedOutstandingBalance as CachedOutstandingBalanceStruct, CachedOutstandingBalanceType, Event as EventStruct, Group as GroupStruct, MemberPlatformMembership as MemberPlatformMembershipStruct, MemberWithRegistrationsBlob, MembersBlob, OrganizationRegistrationPeriod as OrganizationRegistrationPeriodStruct, Organization as OrganizationStruct, PaymentGeneral, PermissionLevel, PrivateOrder, PrivateWebshop, UserWithMembers, WebshopPreview, Webshop as WebshopStruct } from '@stamhoofd/structures';
 
 import { Formatter } from '@stamhoofd/utility';
 import { Context } from './Context';
@@ -423,6 +423,29 @@ export class AuthenticatedStructures {
         return result;
     }
 
+    static async orders(orders: Order[]): Promise<PrivateOrder[]> {
+        // Load groups
+        // const groupIds = orders.map(e => e.groupId).filter(id => id !== null);
+        // const groups = groupIds.length > 0 ? await Group.getByIDs(...groupIds) : [];
+        // const groupStructs = await this.groups(groups);
+
+        const result: PrivateOrder[] = [];
+
+        for (const order of orders) {
+            // const group = groupStructs.find(g => g.id == event.groupId) ?? null;
+
+            const struct = PrivateOrder.create({
+                ...order,
+                // todo!!!!!
+                balanceItems: [],
+            });
+
+            result.push(struct);
+        }
+
+        return result;
+    }
+
     static async cachedOutstandingBalances(balances: CachedOutstandingBalance[]): Promise<CachedOutstandingBalanceStruct[]> {
         if (balances.length === 0) {
             return [];

package/src/helpers/LimitedFilteredRequestHelper.ts

@@ -0,0 +1,24 @@
+import { SimpleError } from '@simonbackx/simple-errors';
+import { LimitedFilteredRequest } from '@stamhoofd/structures';
+
+export class LimitedFilteredRequestHelper {
+    static throwIfInvalidLimit({ request, maxLimit }: { request: LimitedFilteredRequest; maxLimit: number }) {
+        const requestLimit = request.limit;
+
+        if (requestLimit > maxLimit) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be more than ' + maxLimit,
+            });
+        }
+
+        if (requestLimit < 1) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                field: 'limit',
+                message: 'Limit can not be less than 1',
+            });
+        }
+    }
+}

package/src/sql-filters/orders.ts

@@ -0,0 +1,27 @@
+import { baseSQLFilterCompilers, createSQLColumnFilterCompiler, SQLFilterDefinitions } from '@stamhoofd/sql';
+
+export const orderFilterCompilers: SQLFilterDefinitions = {
+    ...baseSQLFilterCompilers,
+    'id': createSQLColumnFilterCompiler('id'),
+    'name': createSQLColumnFilterCompiler('name'),
+    'organizationId': createSQLColumnFilterCompiler('organizationId'),
+    '#': createSQLColumnFilterCompiler('number'),
+    // 'startDate': createSQLColumnFilterCompiler('startDate'),
+    // 'endDate': createSQLColumnFilterCompiler('endDate'),
+    // 'groupIds': createSQLExpressionFilterCompiler(
+    //     SQL.jsonValue(SQL.column('meta'), '$.value.groups[*].id'),
+    //     { isJSONValue: true, isJSONObject: true },
+    // ),
+    // 'defaultAgeGroupIds': createSQLExpressionFilterCompiler(
+    //     SQL.jsonValue(SQL.column('meta'), '$.value.defaultAgeGroupIds'),
+    //     { isJSONValue: true, isJSONObject: true },
+    // ),
+    // 'organizationTagIds': createSQLExpressionFilterCompiler(
+    //     SQL.jsonValue(SQL.column('meta'), '$.value.organizationTagIds'),
+    //     { isJSONValue: true, isJSONObject: true },
+    // ),
+    // 'meta.visible': createSQLExpressionFilterCompiler(
+    //     SQL.jsonValue(SQL.column('meta'), '$.value.visible'),
+    //     { isJSONValue: true, type: SQLValueType.JSONBoolean },
+    // ),
+};

package/src/sql-sorters/orders.ts

@@ -0,0 +1,58 @@
+import { Order } from '@stamhoofd/models';
+import { SQL, SQLOrderBy, SQLOrderByDirection, SQLSortDefinitions } from '@stamhoofd/sql';
+import { Formatter } from '@stamhoofd/utility';
+
+export const orderSorters: SQLSortDefinitions<Order> = {
+    // 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.
+
+    '#': {
+        getValue(a) {
+            return a.number;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('number'),
+                direction,
+            });
+        },
+    },
+    'id': {
+        getValue(a) {
+            return a.id;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('id'),
+                direction,
+            });
+        },
+    },
+    'name': {
+        getValue(a) {
+            return a.id;
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('name'),
+                direction,
+            });
+        },
+    },
+    'createdAt': {
+        getValue(a) {
+            return Formatter.dateTimeIso(a.createdAt);
+        },
+        toSQL: (direction: SQLOrderByDirection): SQLOrderBy => {
+            return new SQLOrderBy({
+                column: SQL.column('createdAt'),
+                direction,
+            });
+        },
+    },
+};