@stamhoofd/backend 2.39.1 → 2.40.0

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

@@ -1,28 +1,28 @@
-import { Request } from "@simonbackx/simple-endpoints";
+import { Request } from '@simonbackx/simple-endpoints';
 import { OrganizationFactory } from '@stamhoofd/models';
 import { OrganizationSimple } from '@stamhoofd/structures';
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv4 } from 'uuid';
 
 import { testServer } from '../../../../tests/helpers/TestServer';
-import { SearchOrganizationEndpoint } from "./SearchOrganizationEndpoint";
+import { SearchOrganizationEndpoint } from './SearchOrganizationEndpoint';
 
-describe("Endpoint.SearchOrganization", () => {
+describe('Endpoint.SearchOrganization', () => {
     // Test endpoint
     const endpoint = new SearchOrganizationEndpoint();
 
-    test("Search for a given organization using exact search", async () => {
+    test('Search for a given organization using exact search', async () => {
         const organization = await new OrganizationFactory({
-            name: (uuidv4()).replace(/-/g, "")
-        }).create()
+            name: (uuidv4()).replace(/-/g, ''),
+        }).create();
 
-        const r = Request.buildJson("GET", "/v19/organizations/search");
+        const r = Request.buildJson('GET', '/v19/organizations/search');
         r.query = {
-            query: organization.name
+            query: organization.name,
         };
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
-        expect(response.body).toHaveLength(1)
+        expect(response.body).toHaveLength(1);
 
         // Access token should be expired
         expect(response.body[0]).toBeInstanceOf(OrganizationSimple);
@@ -30,29 +30,29 @@ describe("Endpoint.SearchOrganization", () => {
         expect(response.body[0]).toMatchObject({
             id: organization.id,
             name: organization.name,
-            address: organization.address
-        })
+            address: organization.address,
+        });
     });
 
-    test("Search for a given organization on city name using exact search", async () => {
-        const city = uuidv4()
+    test('Search for a given organization on city name using exact search', async () => {
+        const city = uuidv4();
         const organizations = await new OrganizationFactory({
-            city
-        }).createMultiple(2)
+            city,
+        }).createMultiple(2);
 
-        const r = Request.buildJson("GET", "/v1/organizations/search");
+        const r = Request.buildJson('GET', '/v1/organizations/search');
         r.query = {
-            query: city
+            query: city,
         };
 
         const response = await testServer.test(endpoint, r);
         expect(response.body).toBeDefined();
-        expect(response.body).toHaveLength(2)
+        expect(response.body).toHaveLength(2);
 
         // Access token should be expired
         expect(response.body[0]).toBeInstanceOf(OrganizationSimple);
         expect(response.body[1]).toBeInstanceOf(OrganizationSimple);
         expect(response.status).toEqual(200);
-        expect(response.body.map(o => o.id).sort()).toEqual(organizations.map(o => o.id).sort())
+        expect(response.body.map(o => o.id).sort()).toEqual(organizations.map(o => o.id).sort());
     });
 });

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

@@ -1,28 +1,28 @@
 import { AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Organization } from "@stamhoofd/models";
-import { Organization as OrganizationStruct,OrganizationSimple } from "@stamhoofd/structures"; 
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { Organization } from '@stamhoofd/models';
+import { Organization as OrganizationStruct, OrganizationSimple } from '@stamhoofd/structures';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 
 type Params = Record<string, never>;
 
 class Query extends AutoEncoder {
     @field({ decoder: StringDecoder })
-    query: string
+    query: string;
 }
 
 type Body = undefined;
-type ResponseBody = (OrganizationSimple | OrganizationStruct)[]
+type ResponseBody = (OrganizationSimple | OrganizationStruct)[];
 
 export class SearchOrganizationEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    protected queryDecoder = Query as Decoder<Query>
+    protected 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, "/organizations/search", {});
+        const params = Endpoint.parseParameters(request.url, '/organizations/search', {});
 
         if (params) {
             return [true, params as Params];
@@ -32,16 +32,16 @@ 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]+$/, "")
+        const query = request.query.query.replace(/([-+><()~*"@\s]+)/g, ' ').replace(/[^\w\d]+$/, '');
         if (query.length == 0) {
             // Do not try searching...
-            return new Response([])
+            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"
+            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
@@ -50,11 +50,11 @@ export class SearchOrganizationEndpoint extends Endpoint<Params, Query, Body, Re
             sort: [
                 {
                     column: { searchIndex: match },
-                    direction: "DESC"
-                }
-            ]
+                    direction: 'DESC',
+                },
+            ],
         });
-        
+
         if (request.request.getVersion() < 169) {
             return new Response(organizations.map(o => OrganizationSimple.create(o)));
         }

package/src/endpoints/global/payments/StripeWebhookEndpoint.ts

@@ -1,4 +1,3 @@
-
 import { AnyDecoder, AutoEncoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
@@ -13,33 +12,33 @@ class Body extends AutoEncoder {
      * The account id (internal id, not the stripe id)
      */
     @field({ decoder: StringDecoder })
-    type: string
+    type: string;
 
     @field({ decoder: StringDecoder })
-    id: string
+    id: string;
 
     /**
      * Set for connect events
      */
     @field({ decoder: StringDecoder, nullable: true, optional: true })
-    account: string|null = null
+    account: string | null = null;
 
     @field({ decoder: AnyDecoder })
-    data: any
+    data: any;
 }
 
-type Query = undefined
-type ResponseBody = undefined
+type Query = undefined;
+type ResponseBody = undefined;
 
 export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = Body as Decoder<Body>
+    bodyDecoder = Body as Decoder<Body>;
 
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method !== "POST") {
+        if (request.method !== 'POST') {
             return [false];
         }
 
-        const params = Endpoint.parseParameters(request.url, "/stripe/webhooks", {});
+        const params = Endpoint.parseParameters(request.url, '/stripe/webhooks', {});
 
         if (params) {
             return [true, params as Params];
@@ -49,104 +48,109 @@ export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, Response
     }
 
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        console.log("Received Stripe Webhook", request.body.type);
+        console.log('Received Stripe Webhook', request.body.type);
 
         // Verify webhook signature and extract the event.
         // See https://stripe.com/docs/webhooks/signatures for more information.
         let event;
         try {
-            const stripe = StripeHelper.getInstance()
+            const stripe = StripeHelper.getInstance();
             const sig = request.headers['stripe-signature'];
             if (!sig) {
                 throw new SimpleError({
-                    code: "invalid_signature",
-                    message: "Invalid signature",
-                    statusCode: 400
-                })
+                    code: 'invalid_signature',
+                    message: 'Invalid signature',
+                    statusCode: 400,
+                });
             }
-            const secret = request.body.account ? STAMHOOFD.STRIPE_CONNECT_ENDPOINT_SECRET : STAMHOOFD.STRIPE_ENDPOINT_SECRET
+            const secret = request.body.account ? STAMHOOFD.STRIPE_CONNECT_ENDPOINT_SECRET : STAMHOOFD.STRIPE_ENDPOINT_SECRET;
             event = await stripe.webhooks.constructEventAsync(await request.request.bodyPromise!, sig, secret);
-        } catch (err) {
+        }
+        catch (err) {
             throw new SimpleError({
-                code: "invalid_signature",
-                message: "Invalid signature",
-                statusCode: 400
-            })
+                code: 'invalid_signature',
+                message: 'Invalid signature',
+                statusCode: 400,
+            });
         }
 
         // Check type
         switch (request.body.type) {
-            case "account.updated": {
+            case 'account.updated': {
                 console.log(event);
                 const account = request.body.data.object;
                 if (account && account.id) {
                     const id = account.id as string;
-                    const [model] = await StripeAccount.where({accountId: id}, {limit: 1});
+                    const [model] = await StripeAccount.where({ accountId: id }, { limit: 1 });
                     if (model) {
-                        model.setMetaFromStripeAccount(account)
-                        await model.save()
-                    } else {
-                        console.warn("Could not find stripe account with id", id)
+                        model.setMetaFromStripeAccount(account);
+                        await model.save();
+                    }
+                    else {
+                        console.warn('Could not find stripe account with id', id);
                     }
                 }
                 break;
             }
-            case "payment_intent.amount_capturable_updated":
-            case "payment_intent.canceled":
-            case "payment_intent.created":
-            case "payment_intent.partially_funded":
-            case "payment_intent.payment_failed":
-            case "payment_intent.processing":
-            case "payment_intent.requires_action":
-            case "payment_intent.succeeded": {
+            case 'payment_intent.amount_capturable_updated':
+            case 'payment_intent.canceled':
+            case 'payment_intent.created':
+            case 'payment_intent.partially_funded':
+            case 'payment_intent.payment_failed':
+            case 'payment_intent.processing':
+            case 'payment_intent.requires_action':
+            case 'payment_intent.succeeded': {
                 const intentId = request.body.data.object.id;
-                
-                if (intentId && typeof intentId === "string") {
-                    await this.updateIntent(intentId)
+
+                if (intentId && typeof intentId === 'string') {
+                    await this.updateIntent(intentId);
                 }
                 break;
             }
-            case "checkout.session.async_payment_failed":
-            case "checkout.session.async_payment_succeeded":
-            case "checkout.session.completed":
-            case "checkout.session.expired": {
+            case 'checkout.session.async_payment_failed':
+            case 'checkout.session.async_payment_succeeded':
+            case 'checkout.session.completed':
+            case 'checkout.session.expired': {
                 const checkoutId = request.body.data.object.id;
-                const [model] = await StripeCheckoutSession.where({stripeSessionId: checkoutId}, {limit: 1})
+                const [model] = await StripeCheckoutSession.where({ stripeSessionId: checkoutId }, { limit: 1 });
                 if (model && model.organizationId) {
-                    const organization = await Organization.getByID(model.organizationId)
+                    const organization = await Organization.getByID(model.organizationId);
                     if (organization) {
-                        await ExchangePaymentEndpoint.pollStatus(model.paymentId, organization)
-                    } else {
-                        console.warn("Could not find organization with id", model.organizationId)
+                        await ExchangePaymentEndpoint.pollStatus(model.paymentId, organization);
+                    }
+                    else {
+                        console.warn('Could not find organization with id', model.organizationId);
                     }
-                } else {
-                    console.warn("Could not find stripe checkout session with id", checkoutId)
+                }
+                else {
+                    console.warn('Could not find stripe checkout session with id', checkoutId);
                 }
                 break;
             }
             // Listen for charge changes (transaction fees will be added here, after the payment intent succeeded)
-            case "charge.captured":
-            case "charge.expired":
-            case "charge.failed":
-            case "charge.pending":
-            case "charge.refunded":
-            case "charge.succeeded":
-            case "charge.dispute.created":
-            case "charge.dispute.updated":
-            case "charge.dispute.closed":
-            case "charge.refund.updated":
-            case "charge.refund.succeeded":
-            case "charge.updated": {
+            case 'charge.captured':
+            case 'charge.expired':
+            case 'charge.failed':
+            case 'charge.pending':
+            case 'charge.refunded':
+            case 'charge.succeeded':
+            case 'charge.dispute.created':
+            case 'charge.dispute.updated':
+            case 'charge.dispute.closed':
+            case 'charge.refund.updated':
+            case 'charge.refund.succeeded':
+            case 'charge.updated': {
                 const intentId = request.body.data.object.payment_intent;
-                if (intentId && typeof intentId === "string") {
-                    await this.updateIntent(intentId)
-                } else {
-                    console.log('Received charge event without payment intent', request.body)
+                if (intentId && typeof intentId === 'string') {
+                    await this.updateIntent(intentId);
+                }
+                else {
+                    console.log('Received charge event without payment intent', request.body);
                 }
                 break;
             }
             default: {
-                console.log("Unhandled stripe webhook type", request.body.type);
+                console.log('Unhandled stripe webhook type', request.body.type);
                 break;
             }
         }
@@ -154,17 +158,19 @@ export class StripeWebookEndpoint extends Endpoint<Params, Query, Body, Response
     }
 
     async updateIntent(intentId: string) {
-        console.log("[Webooks] Updating intent", intentId)
-        const [model] = await StripePaymentIntent.where({stripeIntentId: intentId}, {limit: 1})
+        console.log('[Webooks] Updating intent', intentId);
+        const [model] = await StripePaymentIntent.where({ stripeIntentId: intentId }, { limit: 1 });
         if (model && model.organizationId) {
-            const organization = await Organization.getByID(model.organizationId)
+            const organization = await Organization.getByID(model.organizationId);
             if (organization) {
-                await ExchangePaymentEndpoint.pollStatus(model.paymentId, organization)
-            } else {
-                console.warn("Could not find organization with id", model.organizationId)
+                await ExchangePaymentEndpoint.pollStatus(model.paymentId, organization);
             }
-        } else {
-            console.warn("Could not find stripe payment intent with id", intentId)
+            else {
+                console.warn('Could not find organization with id', model.organizationId);
+            }
+        }
+        else {
+            console.warn('Could not find stripe payment intent with id', intentId);
         }
     }
 }

package/src/endpoints/global/platform/GetPlatformAdminsEndpoint.ts

@@ -1,21 +1,21 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { User } from '@stamhoofd/models';
-import { User as UserStruct } from "@stamhoofd/structures";
+import { User as UserStruct } from '@stamhoofd/structures';
 
-import { Context } from "../../../helpers/Context";
-import { AuthenticatedStructures } from "../../../helpers/AuthenticatedStructures";
+import { Context } from '../../../helpers/Context';
+import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = undefined
-type ResponseBody = UserStruct[]
+type Body = undefined;
+type ResponseBody = UserStruct[];
 
 export class GetPlatformAdminsEndpoint 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, "/platform/admins", {});
+        const params = Endpoint.parseParameters(request.url, '/platform/admins', {});
 
         if (params) {
             return [true, params as Params];
@@ -24,22 +24,22 @@ export class GetPlatformAdminsEndpoint extends Endpoint<Params, Query, Body, Res
     }
 
     async handle(_: DecodedRequest<Params, Query, Body>) {
-        await Context.authenticate()
+        await Context.authenticate();
 
         // Fast throw first (more in depth checking for patches later)
         if (!Context.auth.canManagePlatformAdmins()) {
-            throw Context.auth.error()
+            throw Context.auth.error();
         }
 
         // Get all admins
-        let admins = await User.where({ organizationId: null, permissions: { sign: "!=", value: null }})
+        let admins = await User.where({ organizationId: null, permissions: { sign: '!=', value: null } });
 
         // Hide api accounts
-        admins = admins.filter(a => !a.isApiUser)
-        admins = admins.filter(a => !!a.permissions?.globalPermissions)
+        admins = admins.filter(a => !a.isApiUser);
+        admins = admins.filter(a => !!a.permissions?.globalPermissions);
 
         return new Response(
-            await AuthenticatedStructures.usersWithMembers(admins)
+            await AuthenticatedStructures.usersWithMembers(admins),
         );
     }
 }

package/src/endpoints/global/platform/GetPlatformEnpoint.ts

@@ -1,21 +1,21 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
-import { Platform } from "@stamhoofd/models";
-import { Platform as PlatformStruct } from "@stamhoofd/structures";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
+import { Platform } from '@stamhoofd/models';
+import { Platform as PlatformStruct } from '@stamhoofd/structures';
 
-import { Context } from "../../../helpers/Context";
+import { Context } from '../../../helpers/Context';
 
 type Params = Record<string, never>;
 type Query = undefined;
-type Body = undefined
+type Body = undefined;
 type ResponseBody = PlatformStruct;
 
 export class GetPlatformEndpoint 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, "/platform", {});
+        const params = Endpoint.parseParameters(request.url, '/platform', {});
 
         if (params) {
             return [true, params as Params];
@@ -24,16 +24,16 @@ export class GetPlatformEndpoint extends Endpoint<Params, Query, Body, ResponseB
     }
 
     async handle(_: DecodedRequest<Params, Query, Body>) {
-        await Context.optionalAuthenticate({allowWithoutAccount: false})
+        await Context.optionalAuthenticate({ allowWithoutAccount: false });
 
         if (Context.optionalAuth?.hasSomePlatformAccess()) {
-            const platform = await Platform.getSharedPrivateStruct()
+            const platform = await Platform.getSharedPrivateStruct();
             if (!platform.privateConfig) {
-                throw new Error("Private config not found")
+                throw new Error('Private config not found');
             }
             return new Response(platform);
         }
-        const platform = await Platform.getSharedStruct()
+        const platform = await Platform.getSharedStruct();
         return new Response(platform);
     }
 }