@stamhoofd/backend 2.39.0 → 2.40.0

package/src/endpoints/organization/shared/auth/GetOrganizationEndpoint.test.ts

@@ -1,78 +1,77 @@
-import { Request } from "@simonbackx/simple-endpoints";
+import { Request } from '@simonbackx/simple-endpoints';
 import { GroupFactory, OrganizationFactory, Token, UserFactory } from '@stamhoofd/models';
 import { Organization, PermissionLevel, Permissions } from '@stamhoofd/structures';
 
-import { testServer } from "../../../../../tests/helpers/TestServer";
+import { testServer } from '../../../../../tests/helpers/TestServer';
 import { GetOrganizationEndpoint } from './GetOrganizationEndpoint';
 
-describe("Endpoint.GetOrganization", () => {
+describe('Endpoint.GetOrganization', () => {
     // Test endpoint
     const endpoint = new GetOrganizationEndpoint();
 
-    test("Get organization as signed in user", async () => {
-        const organization = await new OrganizationFactory({}).create()
-        const user = await new UserFactory({ organization }).create()
-        const groups = await new GroupFactory({ organization }).createMultiple(2)
-        const token = await Token.createToken(user)
+    test('Get organization as signed in user', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({ organization }).create();
+        const groups = await new GroupFactory({ organization }).createMultiple(2);
+        const token = await Token.createToken(user);
 
-        const r = Request.buildJson("GET", "/v3/organization", organization.getApiHost());
-        r.headers.authorization = "Bearer " + token.accessToken
+        const r = Request.buildJson('GET', '/v3/organization', organization.getApiHost());
+        r.headers.authorization = 'Bearer ' + token.accessToken;
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
         if (!(response.body instanceof Organization)) {
-            throw new Error("Expected Organization")
+            throw new Error('Expected Organization');
         }
 
-        expect(response.body.id).toEqual(organization.id)
-        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort())
-        expect(response.body.privateMeta).toEqual(null)
+        expect(response.body.id).toEqual(organization.id);
+        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort());
+        expect(response.body.privateMeta).toEqual(null);
     });
 
-    test("Get organization as admin", async () => {
-        const organization = await new OrganizationFactory({}).create()
+    test('Get organization as admin', async () => {
+        const organization = await new OrganizationFactory({}).create();
         const user = await new UserFactory({
             organization,
             permissions: Permissions.create({
-                level: PermissionLevel.Read
-            })
-        }).create()
+                level: PermissionLevel.Read,
+            }),
+        }).create();
 
-        const groups = await new GroupFactory({ organization }).createMultiple(2)
-        const token = await Token.createToken(user)
+        const groups = await new GroupFactory({ organization }).createMultiple(2);
+        const token = await Token.createToken(user);
 
-        const r = Request.buildJson("GET", "/v3/organization", organization.getApiHost());
-        r.headers.authorization = "Bearer " + token.accessToken
+        const r = Request.buildJson('GET', '/v3/organization', organization.getApiHost());
+        r.headers.authorization = 'Bearer ' + token.accessToken;
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
         if (!(response.body instanceof Organization)) {
-            throw new Error("Expected Organization")
+            throw new Error('Expected Organization');
         }
 
-        expect(response.body.id).toEqual(organization.id)
-        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort())
-        expect(response.body.privateMeta).not.toEqual(null)
+        expect(response.body.id).toEqual(organization.id);
+        expect(response.body.groups.map(g => g.id).sort()).toEqual(groups.map(g => g.id).sort());
+        expect(response.body.privateMeta).not.toEqual(null);
     });
 
-     test("Get organization as admin of a different organization", async () => {
-        const organization = await new OrganizationFactory({}).create()
-        const organization2 = await new OrganizationFactory({}).create()
+    test('Get organization as admin of a different organization', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const organization2 = await new OrganizationFactory({}).create();
         const user = await new UserFactory({
             organization: organization2,
             permissions: Permissions.create({
-                level: PermissionLevel.Read
-            })
-        }).create()
+                level: PermissionLevel.Read,
+            }),
+        }).create();
 
-        const token = await Token.createToken(user)
+        const token = await Token.createToken(user);
 
-        const r = Request.buildJson("GET", "/v3/organization", organization.getApiHost());
-        r.headers.authorization = "Bearer " + token.accessToken
+        const r = Request.buildJson('GET', '/v3/organization', organization.getApiHost());
+        r.headers.authorization = 'Bearer ' + token.accessToken;
 
         await expect(testServer.test(endpoint, r)).rejects.toThrow('The access token is invalid');
     });
-
 });

package/src/endpoints/organization/shared/auth/GetOrganizationEndpoint.ts

@@ -1,21 +1,21 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Organization as OrganizationStruct } from "@stamhoofd/structures";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { Organization as OrganizationStruct } from '@stamhoofd/structures';
 
-import { AuthenticatedStructures } from "../../../../helpers/AuthenticatedStructures";
-import { Context } from "../../../../helpers/Context";
+import { AuthenticatedStructures } from '../../../../helpers/AuthenticatedStructures';
+import { Context } from '../../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = undefined
+type Body = undefined;
 type ResponseBody = OrganizationStruct;
 
 export class GetOrganizationEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/organization", {});
+        const params = Endpoint.parseParameters(request.url, '/organization', {});
 
         if (params) {
             return [true, params as Params];
@@ -25,10 +25,10 @@ export class GetOrganizationEndpoint extends Endpoint<Params, Query, Body, Respo
 
     async handle(_: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOrganizationScope();
-        await Context.optionalAuthenticate({allowWithoutAccount: true})
+        await Context.optionalAuthenticate({ allowWithoutAccount: true });
 
         return new Response(
-            await AuthenticatedStructures.organization(organization)
+            await AuthenticatedStructures.organization(organization),
         );
     }
 }

package/src/endpoints/organization/shared/auth/OpenIDConnectCallbackEndpoint.ts

@@ -1,5 +1,5 @@
 import { AnyDecoder, Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 
 import { Context } from '../../../../helpers/Context';
@@ -14,11 +14,11 @@ export class OpenIDConnectCallbackEndpoint extends Endpoint<Params, Query, Body,
     bodyDecoder = AnyDecoder as Decoder<any>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/openid/callback", {});
+        const params = Endpoint.parseParameters(request.url, '/openid/callback', {});
 
         if (params) {
             return [true, params as Params];
@@ -27,18 +27,18 @@ export class OpenIDConnectCallbackEndpoint extends Endpoint<Params, Query, Body,
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope()
-        const configuration = organization.serverMeta.ssoConfiguration
+        const organization = await Context.setOrganizationScope();
+        const configuration = organization.serverMeta.ssoConfiguration;
 
         if (!configuration) {
             throw new SimpleError({
-                code: "invalid_configuration",
-                message: "Invalid configuration",
-                statusCode: 400
+                code: 'invalid_configuration',
+                message: 'Invalid configuration',
+                statusCode: 400,
             });
         }
 
-        const helper = new OpenIDConnectHelper(organization, configuration)
-        return await helper.callback(request)
+        const helper = new OpenIDConnectHelper(organization, configuration);
+        return await helper.callback(request);
     }
-}
+}

package/src/endpoints/organization/shared/auth/OpenIDConnectStartEndpoint.ts

@@ -1,8 +1,8 @@
 import { Decoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Webshop } from '@stamhoofd/models';
-import { StartOpenIDFlowStruct } from "@stamhoofd/structures";
+import { StartOpenIDFlowStruct } from '@stamhoofd/structures';
 
 import { Context } from '../../../../helpers/Context';
 import { OpenIDConnectHelper } from '../../../../helpers/OpenIDConnectHelper';
@@ -16,11 +16,11 @@ export class OpenIDConnectStartEndpoint extends Endpoint<Params, Query, Body, Re
     bodyDecoder = StartOpenIDFlowStruct as Decoder<StartOpenIDFlowStruct>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/openid/start", {});
+        const params = Endpoint.parseParameters(request.url, '/openid/start', {});
 
         if (params) {
             return [true, params as Params];
@@ -30,20 +30,20 @@ export class OpenIDConnectStartEndpoint extends Endpoint<Params, Query, Body, Re
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
         // Check webshop and/or organization
-        const organization = await Context.setOrganizationScope()
+        const organization = await Context.setOrganizationScope();
         const webshopId = request.body.webshopId;
-        let redirectUri = 'https://' + organization.getHost()
-        
+        let redirectUri = 'https://' + organization.getHost();
+
         if (webshopId) {
-            const webshop = await Webshop.getByID(webshopId)
+            const webshop = await Webshop.getByID(webshopId);
             if (!webshop || webshop.organizationId !== organization.id) {
                 throw new SimpleError({
-                    code: "invalid_webshop",
-                    message: "Invalid webshop",
-                    statusCode: 400
+                    code: 'invalid_webshop',
+                    message: 'Invalid webshop',
+                    statusCode: 400,
                 });
             }
-            redirectUri = 'https://' + webshop.setRelation(Webshop.organization, organization).getHost()
+            redirectUri = 'https://' + webshop.setRelation(Webshop.organization, organization).getHost();
         }
 
         if (request.body.redirectUri) {
@@ -51,32 +51,33 @@ export class OpenIDConnectStartEndpoint extends Endpoint<Params, Query, Body, Re
                 const allowedHost = new URL(redirectUri);
                 const givenUrl = new URL(request.body.redirectUri);
 
-                if (allowedHost.host === givenUrl.host && givenUrl.protocol === "https:") {
-                    redirectUri = givenUrl.href
+                if (allowedHost.host === givenUrl.host && givenUrl.protocol === 'https:') {
+                    redirectUri = givenUrl.href;
                 }
-            } catch (e) {
-                console.error('Invalid redirect uri', request.body.redirectUri)
+            }
+            catch (e) {
+                console.error('Invalid redirect uri', request.body.redirectUri);
             }
         }
 
         if (request.body.spaState.length < 10) {
             throw new SimpleError({
-                code: "invalid_state",
-                message: "Invalid state",
-                statusCode: 400
+                code: 'invalid_state',
+                message: 'Invalid state',
+                statusCode: 400,
             });
         }
-        
-        const configuration = organization.serverMeta.ssoConfiguration
+
+        const configuration = organization.serverMeta.ssoConfiguration;
         if (!configuration) {
             throw new SimpleError({
-                code: "invalid_client",
-                message: "SSO not configured",
-                statusCode: 400
+                code: 'invalid_client',
+                message: 'SSO not configured',
+                statusCode: 400,
             });
         }
 
-        const helper = new OpenIDConnectHelper(organization, configuration)
-        return await helper.startAuthCodeFlow(redirectUri, request.body.provider, request.body.spaState, request.body.prompt)
+        const helper = new OpenIDConnectHelper(organization, configuration);
+        return await helper.startAuthCodeFlow(redirectUri, request.body.provider, request.body.spaState, request.body.prompt);
     }
-}
+}

package/src/endpoints/organization/webshops/CheckWebshopDiscountCodesEndpoint.ts

@@ -1,25 +1,25 @@
-import { ArrayDecoder, StringDecoder } from "@simonbackx/simple-encoding";
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { ArrayDecoder, StringDecoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Webshop, WebshopDiscountCode } from '@stamhoofd/models';
-import { DiscountCode } from "@stamhoofd/structures";
+import { DiscountCode } from '@stamhoofd/structures';
 
-import { Context } from "../../../helpers/Context";
+import { Context } from '../../../helpers/Context';
 
 type Params = { id: string };
 type Query = undefined;
-type Body = string[]
-type ResponseBody = DiscountCode[]
+type Body = string[];
+type ResponseBody = DiscountCode[];
 
 export class CheckWebshopDiscountCodesEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = new ArrayDecoder(StringDecoder)
+    bodyDecoder = new ArrayDecoder(StringDecoder);
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/webshop/@id/discount-codes", { id: String });
+        const params = Endpoint.parseParameters(request.url, '/webshop/@id/discount-codes', { id: String });
 
         if (params) {
             return [true, params as Params];
@@ -28,29 +28,29 @@ export class CheckWebshopDiscountCodesEndpoint extends Endpoint<Params, Query, B
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope()
-        const webshop = await Webshop.getByID(request.params.id)
-        if (!webshop || webshop.organizationId != organization.id) {
+        const organization = await Context.setOrganizationScope();
+        const webshop = await Webshop.getByID(request.params.id);
+        if (!webshop || webshop.organizationId !== organization.id) {
             throw new SimpleError({
-                code: "not_found",
-                message: "Webshop not found",
-                human: "Deze webshop bestaat niet (meer)"
-            })
+                code: 'not_found',
+                message: 'Webshop not found',
+                human: 'Deze webshop bestaat niet (meer)',
+            });
         }
 
         if (request.body.length > 10) {
             // Auto limit
-            request.body = request.body.slice(0, 10)
+            request.body = request.body.slice(0, 10);
         }
-        
+
         // Check all discount codes
         // Return all valid ones
         if (request.body.length > 0) {
-            const codes = await WebshopDiscountCode.getActiveCodes(webshop.id, request.body)
+            const codes = await WebshopDiscountCode.getActiveCodes(webshop.id, request.body);
 
             // todo
             return new Response(
-                codes.map(c => c.getStructure())
+                codes.map(c => c.getStructure()),
             );
         }
 

package/src/endpoints/organization/webshops/GetOrderByPaymentEndpoint.ts

@@ -1,23 +1,23 @@
-import { PartialWithoutMethods } from "@simonbackx/simple-encoding";
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { PartialWithoutMethods } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Order } from '@stamhoofd/models';
 import { Payment } from '@stamhoofd/models';
-import { Order as OrderStruct } from "@stamhoofd/structures";
+import { Order as OrderStruct } from '@stamhoofd/structures';
 
-import { Context } from "../../../helpers/Context";
+import { Context } from '../../../helpers/Context';
 type Params = { id: string; paymentId: string };
 type Query = undefined;
-type Body = undefined
-type ResponseBody = OrderStruct
+type Body = undefined;
+type ResponseBody = OrderStruct;
 
 export class GetOrderByPaymentEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/webshop/@id/payment/@paymentId/order", { id: String, paymentId: String });
+        const params = Endpoint.parseParameters(request.url, '/webshop/@id/payment/@paymentId/order', { id: String, paymentId: String });
 
         if (params) {
             return [true, params as Params];
@@ -26,26 +26,26 @@ export class GetOrderByPaymentEndpoint extends Endpoint<Params, Query, Body, Res
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope()
-        const payment = await Payment.getByID(request.params.paymentId)
+        const organization = await Context.setOrganizationScope();
+        const payment = await Payment.getByID(request.params.paymentId);
 
-        if (!payment || payment.organizationId != organization.id) {
+        if (!payment || payment.organizationId !== organization.id) {
             throw new SimpleError({
-                code: "not_found",
-                message: "Order not found",
-                human: "Deze bestelling bestaat niet (meer)"
-            })
+                code: 'not_found',
+                message: 'Order not found',
+                human: 'Deze bestelling bestaat niet (meer)',
+            });
         }
-        const [order] = await Order.where({ paymentId: payment.id }, { limit: 1})
-        if (!order || order.webshopId != request.params.id || order.organizationId != organization.id) {
+        const [order] = await Order.where({ paymentId: payment.id }, { limit: 1 });
+        if (!order || order.webshopId !== request.params.id || order.organizationId !== organization.id) {
             throw new SimpleError({
-                code: "not_found",
-                message: "Order not found",
-                human: "Deze bestelling bestaat niet (meer)"
-            })
+                code: 'not_found',
+                message: 'Order not found',
+                human: 'Deze bestelling bestaat niet (meer)',
+            });
         }
 
-        order.setRelation(Order.payment, payment)
+        order.setRelation(Order.payment, payment);
         return new Response(await order.getStructure());
     }
 }

package/src/endpoints/organization/webshops/GetOrderEndpoint.ts

@@ -1,21 +1,21 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Order } from '@stamhoofd/models';
-import { Order as OrderStruct } from "@stamhoofd/structures";
+import { Order as OrderStruct } from '@stamhoofd/structures';
 
-import { Context } from "../../../helpers/Context";
+import { Context } from '../../../helpers/Context';
 type Params = { id: string; orderId: string };
 type Query = undefined;
-type Body = undefined
-type ResponseBody = OrderStruct
+type Body = undefined;
+type ResponseBody = OrderStruct;
 
 export class GetOrderEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/webshop/@id/order/@orderId", { id: String, orderId: String });
+        const params = Endpoint.parseParameters(request.url, '/webshop/@id/order/@orderId', { id: String, orderId: String });
 
         if (params) {
             return [true, params as Params];
@@ -24,15 +24,15 @@ export class GetOrderEndpoint extends Endpoint<Params, Query, Body, ResponseBody
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope()
-        const order = await Order.getByID(request.params.orderId)
+        const organization = await Context.setOrganizationScope();
+        const order = await Order.getByID(request.params.orderId);
 
-        if (!order || order.webshopId != request.params.id || order.organizationId != organization.id) {
+        if (!order || order.webshopId !== request.params.id || order.organizationId !== organization.id) {
             throw new SimpleError({
-                code: "not_found",
-                message: "Order not found",
-                human: "Deze bestelling bestaat niet (meer)"
-            })
+                code: 'not_found',
+                message: 'Order not found',
+                human: 'Deze bestelling bestaat niet (meer)',
+            });
         }
 
         return new Response(await order.getStructure());