@stamhoofd/backend-sgv-mock 2.122.0

package/LICENSE.md

@@ -0,0 +1,32 @@
+Free Use License for Non-Profit Organizations
+
+Copyright 2020 Codawood BV
+
+Permission is hereby granted, free of charge, to any non-profit organization with fewer than 2,000 members (each, a “Licensee”), to use this software and associated documentation files (the “Software”), subject to the following conditions:
+
+1. Eligibility:
+This license applies only if neither the Licensee nor, if applicable, its parent or umbrella organization, is already subject to an existing license for this project. For the purposes of this license, a “parent or umbrella organization” means any organization with which the Licensee is affiliated, coordinated, or represented as part of a larger collective, including but not limited to national associations or federations.
+
+2. Modifications:
+Modifications to the Software are permitted only if they are published publicly under the MIT License, covering only the modifications; the original Software remains under this license and may not be sublicensed without a separate agreement. Any modification made by a Licensee (other than modifications by the original author, its representatives, or the copyright owner) shall be deemed to be distributed under the MIT License. Submission of modifications through publicly accessible channels, including but not limited to pull requests on code repositories such as GitHub, shall be considered an explicit acknowledgment and grant by the Licensee that such modifications are made available under the MIT License. Licensees may not sublicense, transfer, or assign the rights granted under this license except as expressly permitted herein.
+
+3. Precedence of Existing Licenses:
+If the Licensee, or its parent or umbrella organization, is already subject to an existing license for this project, that license shall take precedence, and no additional free license is granted. Nothing in this license shall be construed to override any pre-existing exclusive license agreement.
+
+4. Data Protection / GDPR Responsibility:
+Licensees are solely responsible for ensuring that any processing of personal data using this software complies with applicable data protection laws, including the EU General Data Protection Regulation (GDPR).
+
+5. Termination and Revocation:
+The copyright holders may revoke this license at any time, at their sole discretion.
+
+6. Governing Law:
+This license shall be governed by and construed in accordance with the laws of Belgium, without regard to conflict of law principles.
+
+7. Third-Party Licenses:
+Certain files or components included in the Software may be governed by separate licenses, including open-source licenses, or contributed by third parties under different terms. Such files are not automatically covered by this license. Licensees are responsible for reviewing and complying with any additional license terms that apply to these files.
+
+For the purposes of this license, a “non-profit organization” means an entity recognized as non-profit under applicable law in its jurisdiction, which does not distribute profits to its members or owners.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.

package/package.json

@@ -0,0 +1,37 @@
+{
+    "name": "@stamhoofd/backend-sgv-mock",
+    "version": "2.122.0",
+    "type": "module",
+    "main": "./dist/index.js",
+    "exports": {
+        ".": {
+            "require": "./dist/index.js"
+        }
+    },
+    "scripts": {
+        "build": "tsc --build tsconfig.build.json",
+        "build:full": "yarn -s clear && yarn -s build",
+        "clear": "rm -rf ./dist && rm -f *.tsbuildinfo",
+        "dev": "wait-on ../../../shared/sgv/dist/index.js && concurrently -r 'yarn -s build --watch --preserveWatchOutput' \"wait-on ./dist/index.js && nodemon --quiet --inspect=5859 --watch dist --watch '../../../shared/sgv/dist/' --ext .ts,.json,.js --delay 1000ms --exec 'node --enable-source-maps ./dist/index.js' --signal SIGTERM\"",
+        "dev:build": "yarn -s build",
+        "dev:full": "yarn -s dev",
+        "lint": "eslint .",
+        "start": "yarn -s build && node --enable-source-maps ./dist/index.js",
+        "test": "vitest"
+    },
+    "dependencies": {
+        "@simonbackx/simple-encoding": "2.26.10",
+        "@simonbackx/simple-endpoints": "1.21.1",
+        "@simonbackx/simple-errors": "*",
+        "@stamhoofd/sgv": "2.122.0"
+    },
+    "devDependencies": {
+        "@types/node": "22.15.34",
+        "vitest": "4.1.8"
+    },
+    "license": "UNLICENCED",
+    "publishConfig": {
+        "access": "public"
+    },
+    "gitHead": "3c022b7d7801fb105acfaa401432a8d029abda61"
+}

package/src/boot.ts

@@ -0,0 +1,73 @@
+import {
+    CORSPreflightEndpoint,
+    Request,
+    Router,
+    RouterServer,
+} from "@simonbackx/simple-endpoints";
+
+process.on("unhandledRejection", (error: Error) => {
+    console.error("unhandledRejection");
+    console.error(error.message, error.stack);
+    process.exit(1);
+});
+
+process.env.TZ = "UTC";
+
+if (new Date().getTimezoneOffset() !== 0) {
+    throw new Error("Process should always run in UTC timezone");
+}
+
+// SGV is an external API and callers do not send Stamhoofd's X-Version header.
+Request.defaultVersion = 1;
+
+/** Starts the standalone SGV mock server with permissive CORS so dashboard and Playwright runs can call it as an external API. */
+const start = async () => {
+    const router = new Router();
+    await router.loadEndpoints(import.meta.dirname + "/endpoints");
+    router.endpoints.push(new CORSPreflightEndpoint());
+
+    const routerServer = new RouterServer(router);
+    routerServer.verbose = false;
+    routerServer.defaultHeaders = {
+        ...routerServer.defaultHeaders,
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Headers": "Authorization, Content-Type, Accept",
+        "Access-Control-Allow-Methods": "GET, POST, PATCH, OPTIONS",
+    };
+
+    const port = Number.parseInt(
+        process.env.PORT ?? process.env.STAMHOOFD_PORT ?? "9094",
+        10,
+    );
+    routerServer.listen(port);
+    console.log(`Started SGV mock on port ${port}.`);
+
+    const shutdown = async () => {
+        console.log("Shutting down SGV mock...");
+        routerServer.defaultHeaders = Object.assign(
+            routerServer.defaultHeaders,
+            { Connection: "close" },
+        );
+        await routerServer.close();
+        process.exit(0);
+    };
+
+    process.on("SIGTERM", () => {
+        shutdown().catch((error) => {
+            console.error(error);
+            process.exit(1);
+        });
+    });
+
+    process.on("SIGINT", () => {
+        shutdown().catch((error) => {
+            console.error(error);
+            process.exit(1);
+        });
+    });
+};
+
+start().catch((error) => {
+    console.error("unhandledRejection", error);
+    process.exit(1);
+});

package/src/endpoints/SGVMockEndpoint.test.ts

@@ -0,0 +1,406 @@
+import { Request, TestServer } from '@simonbackx/simple-endpoints';
+import { ObjectData } from '@simonbackx/simple-encoding';
+import {
+    defaultSGVGroepNumber,
+    SGV_FUNCTION_PATH,
+    SGV_GROUP_PATH,
+    SGV_LOGIN_AUTHORIZE_PATH,
+    SGV_LOGIN_TOKEN_PATH,
+    SGV_MEMBER_LIST_FILTER_PATH,
+    SGV_MEMBER_LIST_PATH,
+    SGV_MEMBER_PATH,
+    SGV_PROFILE_PATH,
+    SGVProfielResponse,
+    SGV_SEARCH_SIMILAR_PATH,
+    sgvMemberPath,
+} from '@stamhoofd/sgv';
+import { sgvMockState } from '../state/mock-state.js';
+import { SGVMockEndpoint } from './SGVMockEndpoint.js';
+
+describe('Endpoint.SGVMock', () => {
+    const endpoint = new SGVMockEndpoint();
+    const testServer = new TestServer();
+
+    beforeEach(() => {
+        sgvMockState.reset();
+    });
+
+    it('shows a debug page at the root path', async () => {
+        const response = await testServer.test(
+            endpoint,
+            Request.get({ path: '/' }),
+        );
+
+        expect(response.status).toBe(200);
+        expect(response.headers).toEqual(
+            expect.objectContaining({
+                'Content-Type': 'text/html; charset=utf-8',
+            }),
+        );
+        expect(response.body).toContain('SGV mock data');
+        expect(response.body).toContain('Existing');
+        expect(response.body).toContain('member-1');
+    });
+
+    it('returns OAuth tokens', async () => {
+        const response = await testServer.test(
+            endpoint,
+            Request.post({ path: SGV_LOGIN_TOKEN_PATH }),
+        );
+
+        expect(response.status).toBe(200);
+        expect(body(response)).toMatchObject({
+            access_token: 'sgv-mock-access-token',
+            refresh_token: 'sgv-mock-refresh-token',
+            expires_in: 3600,
+        });
+    });
+
+    it('redirects OAuth authorize requests to the callback URL', async () => {
+        const response = await testServer.test(
+            endpoint,
+            Request.get({
+                path: SGV_LOGIN_AUTHORIZE_PATH,
+                query: {
+                    client_id: 'client-id',
+                    redirect_uri: 'https://example.com/oauth/sgv',
+                    state: 'state-value',
+                    response_type: 'code',
+                    scope: 'openid',
+                },
+            }),
+        );
+
+        expect(response.status).toBe(302);
+        expect(response.headers.Location).toBe(
+            'https://example.com/oauth/sgv?code=sgv-mock&state=state-value',
+        );
+    });
+
+    it('preserves callback query parameters and URL-encodes OAuth state', async () => {
+        const response = await testServer.test(
+            endpoint,
+            Request.get({
+                path: SGV_LOGIN_AUTHORIZE_PATH,
+                query: {
+                    client_id: 'client-id',
+                    redirect_uri:
+                        'https://example.com/oauth/sgv?existing=value',
+                    state: 'state value&with=symbols',
+                    response_type: 'code',
+                    scope: 'openid',
+                },
+            }),
+        );
+
+        expect(response.status).toBe(302);
+        expect(response.headers.Location).toBe(
+            'https://example.com/oauth/sgv?existing=value&code=sgv-mock&state=state+value%26with%3Dsymbols',
+        );
+    });
+
+    it('rejects OAuth authorize requests with missing parameters', async () => {
+        await expect(
+            testServer.test(
+                endpoint,
+                Request.get({ path: SGV_LOGIN_AUTHORIZE_PATH }),
+            ),
+        ).rejects.toThrow(/Missing OAuth parameter: client_id/);
+    });
+
+    it('accepts authorization-code and refresh-token exchange request bodies', async () => {
+        const authorizationCodeResponse = await testServer.test(
+            endpoint,
+            Request.post({
+                path: SGV_LOGIN_TOKEN_PATH,
+                body: {
+                    client_id: 'client-id',
+                    code: 'sgv-mock',
+                    grant_type: 'authorization_code',
+                    redirect_uri: 'https://example.com/oauth/sgv',
+                },
+            }),
+        );
+        const refreshTokenResponse = await testServer.test(
+            endpoint,
+            Request.post({
+                path: SGV_LOGIN_TOKEN_PATH,
+                body: {
+                    client_id: 'client-id',
+                    refresh_token: 'sgv-mock-refresh-token',
+                    grant_type: 'refresh_token',
+                    redirect_uri: 'https://example.com/oauth/sgv',
+                },
+            }),
+        );
+
+        expect(body(authorizationCodeResponse)).toMatchObject({
+            access_token: 'sgv-mock-access-token',
+        });
+        expect(body(refreshTokenResponse)).toMatchObject({
+            refresh_token: 'sgv-mock-refresh-token',
+        });
+    });
+
+    it('returns the configured group, functions and profile', async () => {
+        const groupResponse = await testServer.test(
+            endpoint,
+            Request.get({ path: SGV_GROUP_PATH }),
+        );
+        const functionResponse = await testServer.test(
+            endpoint,
+            Request.get({
+                path: SGV_FUNCTION_PATH,
+                    query: { groep: defaultSGVGroepNumber },
+            }),
+        );
+        const profileResponse = await testServer.test(
+            endpoint,
+            Request.get({ path: SGV_PROFILE_PATH }),
+        );
+
+        expect(body(groupResponse).groepen).toEqual(
+            expect.arrayContaining([
+                expect.objectContaining({
+                    groepsnummer: defaultSGVGroepNumber,
+                    naam: 'Prins Boudewijn Wetteren',
+                }),
+                expect.objectContaining({
+                    groepsnummer: defaultSGVGroepNumber,
+                    naam: 'Stamhoofd',
+                }),
+            ]),
+        );
+        expect(
+            body(functionResponse).functies.map((f: any) => f.code),
+        ).toContain('JIN');
+        expect(body(profileResponse)).toMatchObject({
+            functies: [{ groep: defaultSGVGroepNumber, code: 'VGA' }],
+        });
+        expect(profileResponse.body).not.toContain('_isAutoEncoder');
+
+        const profile = new ObjectData(body(profileResponse), { version: 0 }).decode(SGVProfielResponse);
+        expect(profile.functies[0].code).toBe('VGA');
+        expect(profile.functies[0].groep).toBe(defaultSGVGroepNumber);
+        expect(profile.functies[0].isActive).toBe(true);
+    });
+
+    it('creates group functions', async () => {
+        const response = await testServer.test(
+            endpoint,
+            Request.post({
+                path: SGV_FUNCTION_PATH,
+                body: {
+                    beschrijving: 'Beheerd in Stamhoofd',
+                    groepen: [defaultSGVGroepNumber],
+                },
+            }),
+        );
+
+        expect(response.status).toBe(201);
+        expect(body(response)).toMatchObject({
+            beschrijving: 'Beheerd in Stamhoofd',
+        });
+        expect(sgvMockState.functions).toHaveLength(7);
+    });
+
+    it('stores the current ledenlijst filter and returns paginated member summaries', async () => {
+        const filterResponse = await testServer.test(
+            endpoint,
+            Request.patch({
+                path: SGV_MEMBER_LIST_FILTER_PATH,
+                body: {
+                    criteria: {
+                        groepen: [defaultSGVGroepNumber],
+                        oudleden: false,
+                    },
+                    type: 'lid',
+                },
+            }),
+        );
+        expect(filterResponse.status).toBe(200);
+        expect(body(filterResponse)).toEqual({});
+
+        const response = await testServer.test(
+            endpoint,
+            Request.get({
+                path: SGV_MEMBER_LIST_PATH,
+                query: { aantal: 1, offset: 0 },
+            }),
+        );
+
+        expect(sgvMockState.currentFilter).toMatchObject({
+            criteria: { groepen: [defaultSGVGroepNumber] },
+        });
+        expect(body(response)).toMatchObject({
+            aantal: 1,
+            offset: 0,
+            totaal: 1,
+            leden: [{ id: 'member-1' }],
+        });
+        expect(
+            body(response).leden[0].waarden[
+                'be.vvksm.groepsadmin.model.column.GeboorteDatumColumn'
+            ],
+        ).toBe('01/02/2000');
+    });
+
+    it('searches similar members', async () => {
+        const response = await testServer.test(
+            endpoint,
+            Request.get({
+                path: SGV_SEARCH_SIMILAR_PATH,
+                query: { voornaam: 'Existing', achternaam: 'Member' },
+            }),
+        );
+
+        expect(body(response)).toMatchObject({
+            leden: [
+                {
+                    id: 'member-1',
+                    voornaam: 'Existing',
+                    achternaam: 'Member',
+                    geboortedatum: '2000-02-01',
+                },
+            ],
+        });
+    });
+
+    it('fetches, creates and patches members', async () => {
+        const existing = await testServer.test(
+            endpoint,
+            Request.get({ path: sgvMemberPath('member-1') }),
+        );
+        expect(body(existing)).toMatchObject({
+            id: 'member-1',
+            vgagegevens: { voornaam: 'Existing' },
+        });
+
+        const created = await testServer.test(
+            endpoint,
+            Request.post({
+                path: `${SGV_MEMBER_PATH}?bevestig=true`,
+                body: {
+                    vgagegevens: {
+                        voornaam: 'New',
+                        achternaam: 'Member',
+                        geboortedatum: '2010-03-04',
+                    },
+                    adressen: [],
+                    contacten: [],
+                    functies: [],
+                },
+            }),
+        );
+        expect(created.status).toBe(201);
+        expect(body(created)).toMatchObject({
+            id: 'member-2',
+            vgagegevens: { voornaam: 'New' },
+        });
+
+        const patched = await testServer.test(
+            endpoint,
+            Request.patch({
+                path: `${sgvMemberPath('member-2')}?bevestig=true`,
+                body: { vgagegevens: { voornaam: 'Updated' } },
+            }),
+        );
+        expect(body(patched)).toMatchObject({
+            id: 'member-2',
+            vgagegevens: { voornaam: 'Updated', achternaam: 'Member' },
+        });
+    });
+
+    it('returns created members in later list pages and the debug page', async () => {
+        await testServer.test(
+            endpoint,
+            Request.post({
+                path: `${SGV_MEMBER_PATH}?bevestig=true`,
+                body: {
+                    vgagegevens: {
+                        voornaam: 'Second',
+                        achternaam: 'Member',
+                        geboortedatum: '2011-03-04',
+                    },
+                    adressen: [],
+                    contacten: [],
+                    functies: [],
+                },
+            }),
+        );
+        await testServer.test(
+            endpoint,
+            Request.post({
+                path: `${SGV_MEMBER_PATH}?bevestig=true`,
+                body: {
+                    vgagegevens: {
+                        voornaam: 'Third',
+                        achternaam: 'Member',
+                        geboortedatum: '2012-03-04',
+                    },
+                    adressen: [],
+                    contacten: [],
+                    functies: [],
+                },
+            }),
+        );
+
+        const page = await testServer.test(
+            endpoint,
+            Request.get({
+                path: SGV_MEMBER_LIST_PATH,
+                query: { aantal: 1, offset: 2 },
+            }),
+        );
+        const debug = await testServer.test(
+            endpoint,
+            Request.get({ path: '/' }),
+        );
+
+        expect(body(page)).toMatchObject({
+            aantal: 1,
+            offset: 2,
+            totaal: 3,
+            leden: [{ id: 'member-3' }],
+        });
+        expect(debug.body).toContain('Third');
+        expect(debug.body).toContain('member-3');
+    });
+
+    it('can end member functions through patches', async () => {
+        const patched = await testServer.test(
+            endpoint,
+            Request.patch({
+                path: `${sgvMemberPath('member-1')}?bevestig=true`,
+                body: {
+                    functies: [
+                        {
+                            functie: 'd5f75b320b812440010b812555c1039b',
+                            groep: defaultSGVGroepNumber,
+                            begin: '2020-01-01',
+                            einde: '2026-01-01',
+                        },
+                    ],
+                },
+            }),
+        );
+
+        expect(body(patched).functies[0]).toMatchObject({
+            functie: 'd5f75b320b812440010b812555c1039b',
+            einde: '2026-01-01',
+        });
+    });
+
+    it('returns an error for unknown members', async () => {
+        await expect(
+            testServer.test(
+                endpoint,
+                Request.get({ path: sgvMemberPath('missing') }),
+            ),
+        ).rejects.toThrow(/SGV member not found/);
+    });
+});
+
+function body(response: { body: any }): any {
+    return JSON.parse(response.body as string);
+}