@stamhoofd/backend 2.79.7 → 2.79.8

package/.nvmrc

@@ -0,0 +1 @@
+20.12

package/index.ts

@@ -1,5 +1,5 @@
 import backendEnv from '@stamhoofd/backend-env';
-backendEnv.load();
+backendEnv.load({ service: 'api' });
 
 import { Column, Database, Migration } from '@simonbackx/simple-database';
 import { CORSPreflightEndpoint, Router, RouterServer } from '@simonbackx/simple-endpoints';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@stamhoofd/backend",
-    "version": "2.79.7",
+    "version": "2.79.8",
     "main": "./dist/index.js",
     "exports": {
         ".": {
@@ -38,14 +38,14 @@
         "@simonbackx/simple-encoding": "2.21.0",
         "@simonbackx/simple-endpoints": "1.19.1",
         "@simonbackx/simple-logging": "^1.0.1",
-        "@stamhoofd/backend-i18n": "2.79.7",
-        "@stamhoofd/backend-middleware": "2.79.7",
-        "@stamhoofd/email": "2.79.7",
-        "@stamhoofd/models": "2.79.7",
-        "@stamhoofd/queues": "2.79.7",
-        "@stamhoofd/sql": "2.79.7",
-        "@stamhoofd/structures": "2.79.7",
-        "@stamhoofd/utility": "2.79.7",
+        "@stamhoofd/backend-i18n": "2.79.8",
+        "@stamhoofd/backend-middleware": "2.79.8",
+        "@stamhoofd/email": "2.79.8",
+        "@stamhoofd/models": "2.79.8",
+        "@stamhoofd/queues": "2.79.8",
+        "@stamhoofd/sql": "2.79.8",
+        "@stamhoofd/structures": "2.79.8",
+        "@stamhoofd/utility": "2.79.8",
         "archiver": "^7.0.1",
         "aws-sdk": "^2.885.0",
         "axios": "1.6.8",
@@ -65,5 +65,5 @@
     "publishConfig": {
         "access": "public"
     },
-    "gitHead": "d8675cbc91c2fcdcc6bbd3b3925ccd8063b15522"
+    "gitHead": "06e4690b6413a21c3466d6ab76da3a883e1441c8"
 }

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

@@ -2,7 +2,7 @@ import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Member, Platform } from '@stamhoofd/models';
-import { SQL, compileToSQLFilter, applySQLSorter } from '@stamhoofd/sql';
+import { SQL, applySQLSorter, compileToSQLFilter } from '@stamhoofd/sql';
 import { CountFilteredRequest, Country, CountryCode, LimitedFilteredRequest, MembersBlob, PaginatedResponse, PermissionLevel, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 import { DataValidator } from '@stamhoofd/utility';
 
@@ -168,7 +168,7 @@ export class GetMembersEndpoint extends Endpoint<Params, Query, Body, ResponseBo
             }
 
             // Is lidnummer?
-            if (!searchFilter && (q.search.match(/^[0-9]{4}-[0-9]{6}-[0-9]{1,2}$/) || q.search.match(/^[0-9]{10}$/))) {
+            if (!searchFilter && (q.search.match(/^[0-9]{4}-[0-9]{6}-[0-9]{1,2}$/) || q.search.match(/^[0-9]{9,10}$/))) {
                 searchFilter = {
                     memberNumber: {
                         $eq: q.search,

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.test.ts

@@ -1,5 +1,5 @@
 import { Request } from '@simonbackx/simple-endpoints';
-import { OrganizationFactory } from '@stamhoofd/models';
+import { Organization, OrganizationFactory } from '@stamhoofd/models';
 import { v4 as uuidv4 } from 'uuid';
 
 import { testServer } from '../../../../tests/helpers/TestServer';
@@ -9,6 +9,10 @@ describe('Endpoint.SearchOrganization', () => {
     // Test endpoint
     const endpoint = new SearchOrganizationEndpoint();
 
+    afterEach(async () => {
+        await Organization.delete();
+    });
+
     test('Search for a given organization using exact search', async () => {
         const organization = await new OrganizationFactory({
             name: (uuidv4()).replace(/-/g, ''),
@@ -51,4 +55,184 @@ describe('Endpoint.SearchOrganization', () => {
         expect(response.status).toEqual(200);
         expect(response.body.map(o => o.id).sort()).toEqual(organizations.map(o => o.id).sort());
     });
+
+    test('Search organization by name using word should return best match first', async () => {
+        const name = 'WAT?';
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization ' + (i + 1),
+                city: 'Waterloo',
+            }).create();
+        }
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization 2 ' + (i + 1),
+                city: 'Wats',
+            }).create();
+        }
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'De Watten ' + (i + 1),
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name,
+        }).create();
+
+        for (let i = 0; i < 2; i++) {
+            await new OrganizationFactory({
+                name: 'De Watten 2 ' + (i + 1),
+            }).create();
+        }
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query: name,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(9);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using sentence should return best match first', async () => {
+        const query = 'Spaghetti Vreters';
+
+        for (const name of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'De Spaghetti Vretersschool']) {
+            await new OrganizationFactory({
+                name,
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(6);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using word should return organization with searchindex that starts with query first if limit reached', async () => {
+        const query = 'Gent';
+
+        for (let i = 0; i < 10; i++) {
+            await new OrganizationFactory({
+                name: 'Some other Gent organization ' + (i + 1),
+                city: 'Gent',
+            }).create();
+        }
+
+        for (let i = 0; i < 5; i++) {
+            await new OrganizationFactory({
+                name: 'De Gentenaars ' + (i + 1),
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'Gent',
+        }).create();
+
+        for (let i = 0; i < 3; i++) {
+            await new OrganizationFactory({
+                name: 'De Gentenaars 2 ' + (i + 1),
+            }).create();
+        }
+
+        for (let i = 0; i < 10; i++) {
+            await new OrganizationFactory({
+                name: 'Some other organization 2 ' + (i + 1),
+                city: 'Gent',
+            }).create();
+        }
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(15);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name using sentence should return organization with name that starts with query first if limit reached', async () => {
+        const query = 'De Spaghetti Vreters';
+
+        // without the where like (if the limit is reached), 'Spaghetti Vreters Spaghetti Vreters' would come first ('De' is a stopword)
+        for (const name of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'Spaghetti Vreters', 'Spaghetti Vreters Spaghetti Vreters', 'De Spaghetti Vretersschool', 'Spaghetti 2', 'Spaghetti 3', 'Spaghetti 4', 'Spaghetti 5', 'Spaghetti 6', 'Spaghetti 7', 'Spaghetti 8', 'Spaghetti 9', 'Spaghetti 10']) {
+            await new OrganizationFactory({
+                name,
+            }).create();
+        }
+
+        let i = 1;
+        for (const city of ['De Spaghetti Eters', 'Vreters', 'Spaghetti', 'De Spaghetti', 'De Spaghetti Vretersschool']) {
+            await new OrganizationFactory({
+                name: 'name ' + i,
+                city,
+            }).create();
+            i = i + 1;
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(15);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
+
+    test('Search on organization by name and city should return organization that matches city and name first', async () => {
+        const query = 'De Spaghetti Vreters Gent';
+
+        for (let i = 0; i < 5; i++) {
+            await new OrganizationFactory({
+                name: 'De Spaghetti Vreters ' + (i + 1),
+                city: 'Wetteren',
+            }).create();
+        }
+
+        // should appear first in results
+        const targetOrganization = await new OrganizationFactory({
+            name: 'De Spaghetti Vreters 16',
+            city: 'Gent',
+        }).create();
+
+        const r = Request.buildJson('GET', '/v1/organizations/search');
+        r.query = {
+            query,
+        };
+
+        const response = await testServer.test(endpoint, r);
+        expect(response.body).toBeDefined();
+        expect(response.body).toHaveLength(6);
+        expect(response.body[0].name).toEqual(targetOrganization.name);
+        expect(response.body[0].id).toEqual(targetOrganization.id);
+    });
 });

package/src/endpoints/global/organizations/SearchOrganizationEndpoint.ts

@@ -1,6 +1,7 @@
 import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Organization } from '@stamhoofd/models';
+import { scalarToSQLExpression, SQL, SQLMatch, SQLWhere, SQLWhereLike } from '@stamhoofd/sql';
 import { Organization as OrganizationStruct } from '@stamhoofd/structures';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 
@@ -32,28 +33,45 @@ export class SearchOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         // Escape query
-        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ').replace(/[^\w\d]+$/, '');
-        if (query.length == 0) {
+        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ').replace(/[^\w\d]+$/, '').trim();
+        if (query.length === 0) {
             // Do not try searching...
             return new Response([]);
         }
 
-        const match = {
-            sign: 'MATCH',
-            value: query + '*', // We replace special operators in boolean mode with spaces since special characters aren't indexed anyway
-            mode: 'BOOLEAN',
-        };
-
-        // We had to add an order by in the query to fix the limit. MySQL doesn't want to limit the results correctly if we don't explicitly sort the results on their relevance
-        const organizations = await Organization.where({ searchIndex: match, active: 1 }, {
-            limit: 15,
-            sort: [
-                {
-                    column: { searchIndex: match },
-                    direction: 'DESC',
-                },
-            ],
-        });
+        let matchValue: string;
+
+        if (query.includes(' ')) {
+            // give higher relevance if the searchindex includes the exact sentence
+            // give lower relevance if the last word is not a complete match
+            matchValue = `>("${query}") (${query}) <(${query}*)`;
+        }
+        else {
+            // give higher relevance if the searchindex includes the exact word
+            matchValue = `>${query} ${query}*`;
+        }
+
+        const limit = 15;
+
+        const whereMatch: SQLWhere = new SQLMatch(SQL.column(Organization.table, 'searchIndex'), scalarToSQLExpression(matchValue));
+
+        let organizations = await Organization.select()
+            .where(whereMatch)
+            .orderBy(whereMatch, 'DESC')
+            .limit(limit).fetch();
+
+        // if the limit is reached it is possible that organizations where the name starts with the query are missing -> fetch them and add them at the start
+        if (organizations.length === limit) {
+            const organizationsStartingWith = await Organization.select()
+                .where(new SQLWhereLike(SQL.column(Organization.table, 'name'), scalarToSQLExpression(`${query}%`)))
+                // order by relevance
+                .orderBy(whereMatch, 'DESC')
+                .limit(limit).fetch();
+
+            const organizationsStartingWithIds = new Set(organizationsStartingWith.map(o => o.id));
+
+            organizations = organizationsStartingWith.concat(organizations.filter(o => !organizationsStartingWithIds.has(o.id)));
+        }
 
         return new Response(await Promise.all(organizations.map(o => AuthenticatedStructures.organization(o))));
     }

package/src/endpoints/organization/dashboard/organization/PatchOrganizationEndpoint.ts

@@ -352,6 +352,15 @@ export class PatchOrganizationEndpoint extends Endpoint<Params, Query, Body, Res
                     });
                 }
 
+                const maximumStart = 1000 * 60 * 60 * 24 * 31 * 2; // 2 months in advance
+                if (period.startDate > new Date(Date.now() + maximumStart)) {
+                    throw new SimpleError({
+                        code: 'invalid_field',
+                        message: 'Het werkjaar die je wilt instellen is nog niet gestart',
+                        field: 'period',
+                    });
+                }
+
                 organization.periodId = period.id;
                 shouldUpdateSetupSteps = true;
             }

package/src/endpoints/organization/dashboard/registration-periods/PatchOrganizationRegistrationPeriodsEndpoint.ts

@@ -280,6 +280,15 @@ export class PatchOrganizationRegistrationPeriodsEndpoint extends Endpoint<Param
             });
         }
 
+        const maximumStart = 1000 * 60 * 60 * 24 * 31 * 2; // 2 months in advance
+        if (period.startDate > new Date(Date.now() + maximumStart)) {
+            throw new SimpleError({
+                code: 'invalid_field',
+                message: 'Het werkjaar die je wilt instellen is nog niet gestart',
+                field: 'period',
+            });
+        }
+
         const organizationPeriod = new OrganizationRegistrationPeriod();
         organizationPeriod.id = struct.id;
         organizationPeriod.organizationId = organization.id;