@stamhoofd/backend 2.39.1 → 2.40.0

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

@@ -1,10 +1,10 @@
-import { AutoEncoder, Decoder, field, StringDecoder } from "@simonbackx/simple-encoding";
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { SimpleError } from "@simonbackx/simple-errors";
+import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { SimpleError } from '@simonbackx/simple-errors';
 import { Order, Ticket } from '@stamhoofd/models';
-import { TicketOrder, TicketPublic } from "@stamhoofd/structures";
+import { TicketOrder, TicketPublic } from '@stamhoofd/structures';
 
-import { Context } from "../../../helpers/Context";
+import { Context } from '../../../helpers/Context';
 type Params = { id: string };
 
 class Query extends AutoEncoder {
@@ -12,28 +12,28 @@ class Query extends AutoEncoder {
      * Get one ticket by the secret of an individual ticket
      */
     @field({ decoder: StringDecoder, optional: true })
-    secret?: string
+    secret?: string;
 
     /**
      * Get all tickets of a single order if key is not passed.
      * If key is passed, only return a single ticket, but exclude item information
      */
     @field({ decoder: StringDecoder, optional: true })
-    orderId?: string
+    orderId?: string;
 }
 
-type Body = undefined
-type ResponseBody = TicketPublic[] | TicketOrder[]
+type Body = undefined;
+type ResponseBody = TicketPublic[] | TicketOrder[];
 
 export class GetTicketsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = Query as Decoder<Query>
-    
+    queryDecoder = Query as Decoder<Query>;
+
     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/tickets", { id: String });
+        const params = Endpoint.parseParameters(request.url, '/webshop/@id/tickets', { id: String });
 
         if (params) {
             return [true, params as Params];
@@ -42,83 +42,84 @@ export class GetTicketsEndpoint extends Endpoint<Params, Query, Body, ResponseBo
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const organization = await Context.setOrganizationScope()
-        
+        const organization = await Context.setOrganizationScope();
+
         if (request.query.secret) {
-            const [ticket] = await Ticket.where({ 
-                secret: request.query.secret, 
+            const [ticket] = await Ticket.where({
+                secret: request.query.secret,
                 webshopId: request.params.id,
-                organizationId: organization.id
-            }, { limit: 1 })
+                organizationId: organization.id,
+            }, { limit: 1 });
 
             if (!ticket || (request.query.orderId && ticket.orderId !== request.query.orderId) || ticket.isDeleted) {
                 throw new SimpleError({
-                    code: "not_found",
-                    message: "Ticket not found",
-                    human: "Dit ticket bestaat niet"
-                })
+                    code: 'not_found',
+                    message: 'Ticket not found',
+                    human: 'Dit ticket bestaat niet',
+                });
             }
 
             if (!request.query.orderId) {
                 // Include item data
-                const order = await Order.getByID(ticket.orderId)
+                const order = await Order.getByID(ticket.orderId);
                 if (!order || order.webshopId !== request.params.id) {
-                    console.error("Error: missing order "+ticket.orderId+" for ticket "+ticket.id)
+                    console.error('Error: missing order ' + ticket.orderId + ' for ticket ' + ticket.id);
                     throw new SimpleError({
-                        code: "not_found",
-                        message: "Ticket not found",
-                        human: "Dit ticket bestaat niet"
-                    })
+                        code: 'not_found',
+                        message: 'Ticket not found',
+                        human: 'Dit ticket bestaat niet',
+                    });
                 }
 
                 if (ticket.itemId) {
-                    const item = order.data.cart.items.find(i => i.id === ticket.itemId)
-                    
+                    const item = order.data.cart.items.find(i => i.id === ticket.itemId);
+
                     if (!item) {
-                        console.error("Error: missing item "+ticket.itemId+" for ticket "+ticket.id)
+                        console.error('Error: missing item ' + ticket.itemId + ' for ticket ' + ticket.id);
                         throw new SimpleError({
-                            code: "not_found",
-                            message: "Ticket not found",
-                            human: "Dit ticket bestaat niet"
-                        })
+                            code: 'not_found',
+                            message: 'Ticket not found',
+                            human: 'Dit ticket bestaat niet',
+                        });
                     }
 
                     return new Response([
                         TicketPublic.create({
                             ...ticket,
-                            items: [item]
-                        })
-                    ]); 
-
-                } else {
+                            items: [item],
+                        }),
+                    ]);
+                }
+                else {
                     return new Response([
                         TicketPublic.create({
                             ...ticket,
-                            items: order.data.cart.items
-                        })
-                    ]); 
+                            items: order.data.cart.items,
+                        }),
+                    ]);
                 }
             }
             return new Response([
-                TicketOrder.create(ticket)
-            ]); 
-        } else {
+                TicketOrder.create(ticket),
+            ]);
+        }
+        else {
             if (!request.query.orderId) {
                 throw new SimpleError({
-                    code: "not_found",
-                    message: "At least one query parameter expected: secret, orderId"
-                })
+                    code: 'not_found',
+                    message: 'At least one query parameter expected: secret, orderId',
+                });
             }
 
-            const tickets = await Ticket.where({ 
-                orderId: request.query.orderId, 
+            const tickets = await Ticket.where({
+                orderId: request.query.orderId,
                 webshopId: request.params.id,
                 organizationId: organization.id,
-                deletedAt: null
-            })
+                deletedAt: null,
+            });
             return new Response(
-                tickets.map(ticket => TicketOrder.create(ticket))
-            ); 
+                tickets.map(ticket => TicketOrder.create(ticket)),
+            );
         }
     }
 }

package/src/endpoints/organization/webshops/GetWebshopEndpoint.test.ts

@@ -1,130 +1,129 @@
-import { Request } from "@simonbackx/simple-endpoints";
+import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory, Token, UserFactory, WebshopFactory } from '@stamhoofd/models';
-import { PermissionLevel, Permissions, PrivateWebshop, Webshop as WebshopStruct  } from '@stamhoofd/structures';
+import { PermissionLevel, Permissions, PrivateWebshop, Webshop as WebshopStruct } from '@stamhoofd/structures';
 
-import { testServer } from "../../../../tests/helpers/TestServer";
+import { testServer } from '../../../../tests/helpers/TestServer';
 import { GetWebshopEndpoint } from './GetWebshopEndpoint';
 
-describe("Endpoint.GetWebshop", () => {
+describe('Endpoint.GetWebshop', () => {
     // Test endpoint
     const endpoint = new GetWebshopEndpoint();
 
-    test("Get webshop as signed in user", async () => {
-        const organization = await new OrganizationFactory({}).create()
-        const user = await new UserFactory({ organization }).create()
-        const token = await Token.createToken(user)
-        const webshop = await new WebshopFactory({ organizationId: organization.id }).create()
+    test('Get webshop as signed in user', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const user = await new UserFactory({ organization }).create();
+        const token = await Token.createToken(user);
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
 
-        const r = Request.buildJson("GET", "/v244/webshop/" + webshop.id, organization.getApiHost());
-        r.headers.authorization = "Bearer " + token.accessToken
+        const r = Request.buildJson('GET', '/v244/webshop/' + webshop.id, organization.getApiHost());
+        r.headers.authorization = 'Bearer ' + token.accessToken;
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
-        expect(response.body.id).toEqual(webshop.id)
-        expect((response.body as any).privateMeta).toBeUndefined()
+        expect(response.body.id).toEqual(webshop.id);
+        expect((response.body as any).privateMeta).toBeUndefined();
     });
 
-    test("Allow access without organization scope in old v243", async () => {
-        const organization = await new OrganizationFactory({}).create()
-        const webshop = await new WebshopFactory({ organizationId: organization.id }).create()
+    test('Allow access without organization scope in old v243', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
 
-        const r = Request.buildJson("GET", "/v243/webshop/" + webshop.id);
+        const r = Request.buildJson('GET', '/v243/webshop/' + webshop.id);
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
-        expect(response.body.id).toEqual(webshop.id)
-        expect((response.body as any).privateMeta).toBeUndefined()
+        expect(response.body.id).toEqual(webshop.id);
+        expect((response.body as any).privateMeta).toBeUndefined();
     });
 
-    test("Do not allow access without organization scope in v244", async () => {
-        const organization = await new OrganizationFactory({}).create()
-        const webshop = await new WebshopFactory({ organizationId: organization.id }).create()
-        const r = Request.buildJson("GET", "/v244/webshop/" + webshop.id);
+    test('Do not allow access without organization scope in v244', async () => {
+        const organization = await new OrganizationFactory({}).create();
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
+        const r = Request.buildJson('GET', '/v244/webshop/' + webshop.id);
         await expect(testServer.test(endpoint, r)).rejects.toThrow('Please specify the organization in the hostname');
     });
 
-    test("Get webshop as admin", async () => {
-        const organization = await new OrganizationFactory({}).create()
+    test('Get webshop as admin', async () => {
+        const organization = await new OrganizationFactory({}).create();
         const user = await new UserFactory({
             organization,
             permissions: Permissions.create({
-                level: PermissionLevel.Read
-            })
-        }).create()
-        const token = await Token.createToken(user)
+                level: PermissionLevel.Read,
+            }),
+        }).create();
+        const token = await Token.createToken(user);
 
-        const webshop = await new WebshopFactory({ organizationId: organization.id }).create()
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
 
-        const r = Request.buildJson("GET", "/v244/webshop/" + webshop.id, organization.getApiHost());
-        r.headers.authorization = "Bearer " + token.accessToken
+        const r = Request.buildJson('GET', '/v244/webshop/' + webshop.id, organization.getApiHost());
+        r.headers.authorization = 'Bearer ' + token.accessToken;
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
-        expect(response.body.id).toEqual(webshop.id)
-        expect((response.body as any).privateMeta).toBeDefined()
+        expect(response.body.id).toEqual(webshop.id);
+        expect((response.body as any).privateMeta).toBeDefined();
     });
 
-    test("Get webshop as admin that does not have access to specific webshop", async () => {
-        const organization = await new OrganizationFactory({}).create()
+    test('Get webshop as admin that does not have access to specific webshop', async () => {
+        const organization = await new OrganizationFactory({}).create();
         const user = await new UserFactory({
             organization,
             permissions: Permissions.create({
-                level: PermissionLevel.None
-            })
-        }).create()
-        const token = await Token.createToken(user)
+                level: PermissionLevel.None,
+            }),
+        }).create();
+        const token = await Token.createToken(user);
 
-        const webshop = await new WebshopFactory({ organizationId: organization.id }).create()
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
 
-        const r = Request.buildJson("GET", "/v244/webshop/" + webshop.id, organization.getApiHost());
-        r.headers.authorization = "Bearer " + token.accessToken
+        const r = Request.buildJson('GET', '/v244/webshop/' + webshop.id, organization.getApiHost());
+        r.headers.authorization = 'Bearer ' + token.accessToken;
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
 
-        expect(response.body.id).toEqual(webshop.id)
-        expect((response.body as any).privateMeta).toBeUndefined()
+        expect(response.body.id).toEqual(webshop.id);
+        expect((response.body as any).privateMeta).toBeUndefined();
     });
 
-     test("Get webshop as admin of a different organization", async () => {
-        const organization = await new OrganizationFactory({}).create()
-        const organization2 = await new OrganizationFactory({}).create()
+    test('Get webshop 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 webshop = await new WebshopFactory({ organizationId: organization.id }).create()
+        const token = await Token.createToken(user);
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
 
-        const r = Request.buildJson("GET", "/v244/webshop/" + webshop.id, organization.getApiHost());
-        r.headers.authorization = "Bearer " + token.accessToken
+        const r = Request.buildJson('GET', '/v244/webshop/' + webshop.id, organization.getApiHost());
+        r.headers.authorization = 'Bearer ' + token.accessToken;
 
         await expect(testServer.test(endpoint, r)).rejects.toThrow('The access token is invalid');
     });
 
-    test("If organization scope is missing in v243, access is still checked correctly", async () => {
-        const organization = await new OrganizationFactory({}).create()
-        const organization2 = await new OrganizationFactory({}).create()
+    test('If organization scope is missing in v243, access is still checked correctly', 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.Full
-            })
-        }).create()
+                level: PermissionLevel.Full,
+            }),
+        }).create();
 
-        const token = await Token.createToken(user)
-        const webshop = await new WebshopFactory({ organizationId: organization.id }).create()
+        const token = await Token.createToken(user);
+        const webshop = await new WebshopFactory({ organizationId: organization.id }).create();
 
-        const r = Request.buildJson("GET", "/v243/webshop/" + webshop.id);
-        r.headers.authorization = "Bearer " + token.accessToken
+        const r = Request.buildJson('GET', '/v243/webshop/' + webshop.id);
+        r.headers.authorization = 'Bearer ' + token.accessToken;
 
         await expect(testServer.test(endpoint, r)).rejects.toThrow('The access token is invalid');
     });
-
 });

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

@@ -1,23 +1,23 @@
-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 { Webshop } from '@stamhoofd/models';
-import { PrivateWebshop, Webshop as WebshopStruct } from "@stamhoofd/structures";
+import { PrivateWebshop, Webshop as WebshopStruct } 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 = { id: string };
 type Query = undefined;
-type Body = undefined
+type Body = undefined;
 type ResponseBody = PrivateWebshop | WebshopStruct;
 
 export class GetWebshopEndpoint 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", { id: String });
+        const params = Endpoint.parseParameters(request.url, '/webshop/@id', { id: String });
 
         if (params) {
             return [true, params as Params];
@@ -28,23 +28,24 @@ export class GetWebshopEndpoint extends Endpoint<Params, Query, Body, ResponseBo
     async handle(request: DecodedRequest<Params, Query, Body>) {
         if (Context.version < 244) {
             await Context.setOptionalOrganizationScope();
-        } else {
+        }
+        else {
             await Context.setOrganizationScope();
         }
-        
-        await Context.optionalAuthenticate()
 
-        const webshop = await Webshop.getByID(request.params.id)
+        await Context.optionalAuthenticate();
+
+        const webshop = await Webshop.getByID(request.params.id);
         if (!webshop) {
             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)',
+            });
         }
-        
+
         return new Response(
-            await AuthenticatedStructures.webshop(webshop)
+            await AuthenticatedStructures.webshop(webshop),
         );
     }
 }