npm - @stamhoofd/backend - Versions diffs - 2.39.0 → 2.40.0 - Mend

@stamhoofd/backend 2.39.0 → 2.40.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (198) hide show

package/src/endpoints/global/email/GetEmailEndpoint.ts CHANGED Viewed

@@ -1,13 +1,13 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Email } from '@stamhoofd/models';
-import { EmailPreview } from "@stamhoofd/structures";
+import { EmailPreview } from '@stamhoofd/structures';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Context } from '../../../helpers/Context';
-type Params = {id: string};
+type Params = { id: string };
 type Query = undefined;
-type Body = undefined
+type Body = undefined;
 type ResponseBody = EmailPreview;
 /**
@@ -16,11 +16,11 @@ type ResponseBody = EmailPreview;
 export class GetEmailEndpoint 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, "/email/@id", {id: String});
+        const params = Endpoint.parseParameters(request.url, '/email/@id', { id: String });
         if (params) {
             return [true, params as Params];
@@ -30,20 +30,20 @@ export class GetEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOptionalOrganizationScope();
-        const {user} = await Context.authenticate()
+        const { user } = await Context.authenticate();
         if (!Context.auth.canSendEmails()) {
-            throw Context.auth.error()
-        }
+            throw Context.auth.error();
+        }
         const model = await Email.getByID(request.params.id);
         if (!model || model.userId !== user.id || (model.organizationId !== (organization?.id ?? null))) {
             throw new SimpleError({
-                code: "not_found",
-                human: "Email not found",
+                code: 'not_found',
+                human: 'Email not found',
                 message: 'Deze e-mail bestaat niet of is verwijderd',
-                statusCode: 404
-            })
+                statusCode: 404,
+            });
         }
         return new Response(await model.getPreviewStructure());

package/src/endpoints/global/email/ManageEmailAddressEndpoint.ts CHANGED Viewed

@@ -1,5 +1,5 @@
 import { AutoEncoder, BooleanDecoder, Decoder, field, StringDecoder } from '@simonbackx/simple-encoding';
-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 { EmailAddress } from '@stamhoofd/email';
@@ -8,16 +8,16 @@ type Query = undefined;
 class Body extends AutoEncoder {
     @field({ decoder: StringDecoder })
-    id: string
+    id: string;
     @field({ decoder: StringDecoder })
-    token: string
+    token: string;
     @field({ decoder: BooleanDecoder, optional: true })
-    unsubscribedMarketing?: boolean
+    unsubscribedMarketing?: boolean;
     @field({ decoder: BooleanDecoder, optional: true })
-    unsubscribedAll?: boolean
+    unsubscribedAll?: boolean;
 }
 type ResponseBody = undefined;
@@ -26,11 +26,11 @@ export class ManageEmailAddressEndpoint extends Endpoint<Params, Query, Body, Re
     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, "/email/manage", {});
+        const params = Endpoint.parseParameters(request.url, '/email/manage', {});
         if (params) {
             return [true, params as Params];
@@ -39,19 +39,19 @@ export class ManageEmailAddressEndpoint extends Endpoint<Params, Query, Body, Re
     }
     async handle(request: DecodedRequest<Params, Query, Body>) {
-        const email = await EmailAddress.getByID(request.body.id)
+        const email = await EmailAddress.getByID(request.body.id);
         if (!email || email.token !== request.body.token || request.body.token.length < 10 || request.body.id.length < 10) {
             throw new SimpleError({
-                code: "invalid_fields",
-                message: "Invalid token or id",
-                human: "Deze link is vervallen. Probeer het opnieuw in een recentere e-mail"
-            })
+                code: 'invalid_fields',
+                message: 'Invalid token or id',
+                human: 'Deze link is vervallen. Probeer het opnieuw in een recentere e-mail',
+            });
         }
-        email.unsubscribedAll = request.body.unsubscribedAll ?? email.unsubscribedAll
-        email.unsubscribedMarketing = request.body.unsubscribedMarketing ?? email.unsubscribedMarketing
+        email.unsubscribedAll = request.body.unsubscribedAll ?? email.unsubscribedAll;
+        email.unsubscribedMarketing = request.body.unsubscribedMarketing ?? email.unsubscribedMarketing;
-        await email.save()
+        await email.save();
         return new Response(undefined);
     }
-}
+}

package/src/endpoints/global/email/PatchEmailEndpoint.ts CHANGED Viewed

@@ -1,14 +1,14 @@
-import { DecodedRequest, Endpoint, Request, Response } from "@simonbackx/simple-endpoints";
+import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { Email } from '@stamhoofd/models';
-import { EmailPreview, EmailStatus, Email as EmailStruct } from "@stamhoofd/structures";
+import { EmailPreview, EmailStatus, Email as EmailStruct } from '@stamhoofd/structures';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Context } from '../../../helpers/Context';
-import { AutoEncoderPatchType, Decoder, patchObject } from "@simonbackx/simple-encoding";
+import { AutoEncoderPatchType, Decoder, patchObject } from '@simonbackx/simple-encoding';
-type Params = {id: string};
+type Params = { id: string };
 type Query = undefined;
-type Body = AutoEncoderPatchType<EmailStruct>
+type Body = AutoEncoderPatchType<EmailStruct>;
 type ResponseBody = EmailPreview;
 /**
@@ -16,14 +16,14 @@ type ResponseBody = EmailPreview;
  */
 export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    bodyDecoder = EmailStruct.patchType() as Decoder<AutoEncoderPatchType<EmailStruct>>
+    bodyDecoder = EmailStruct.patchType() as Decoder<AutoEncoderPatchType<EmailStruct>>;
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "PATCH") {
+        if (request.method !== 'PATCH') {
             return [false];
         }
-        const params = Endpoint.parseParameters(request.url, "/email/@id", {id: String});
+        const params = Endpoint.parseParameters(request.url, '/email/@id', { id: String });
         if (params) {
             return [true, params as Params];
@@ -33,29 +33,29 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
     async handle(request: DecodedRequest<Params, Query, Body>) {
         const organization = await Context.setOptionalOrganizationScope();
-        const {user} = await Context.authenticate()
+        const { user } = await Context.authenticate();
         if (!Context.auth.canSendEmails()) {
-            throw Context.auth.error()
-        }
+            throw Context.auth.error();
+        }
         const model = await Email.getByID(request.params.id);
         if (!model || model.userId !== user.id || (model.organizationId !== (organization?.id ?? null))) {
             throw new SimpleError({
-                code: "not_found",
-                human: "Email not found",
+                code: 'not_found',
+                human: 'Email not found',
                 message: 'Deze e-mail bestaat niet of is verwijderd',
-                statusCode: 404
-            })
+                statusCode: 404,
+            });
         }
         if (model.status !== EmailStatus.Draft) {
             throw new SimpleError({
-                code: "not_draft",
-                human: "Email is not a draft",
+                code: 'not_draft',
+                human: 'Email is not a draft',
                 message: 'Deze e-mail is al verzonden en kan niet meer aangepast worden',
-                statusCode: 400
-            })
+                statusCode: 400,
+            });
         }
         let rebuild = false;
@@ -92,22 +92,22 @@ export class PatchEmailEndpoint extends Endpoint<Params, Query, Body, ResponseBo
         // Attachments
         if (request.body.attachments !== undefined) {
             model.attachments = patchObject(model.attachments, request.body.attachments);
-            model.validateAttachments()
+            model.validateAttachments();
         }
         await model.save();
         if (rebuild) {
-            await model.buildExampleRecipient()
-            model.updateCount()
+            await model.buildExampleRecipient();
+            model.updateCount();
             // Force null - because we have stale data
-            model.recipientCount = null
+            model.recipientCount = null;
         }
         if (request.body.status === EmailStatus.Sending || request.body.status === EmailStatus.Sent) {
-            model.throwIfNotReadyToSend()
-            model.send().catch(console.error)
+            model.throwIfNotReadyToSend();
+            model.send().catch(console.error);
         }
         return new Response(await model.getPreviewStructure());

package/src/endpoints/global/events/GetEventsEndpoint.ts CHANGED Viewed

@@ -1,9 +1,8 @@
-/* eslint-disable @typescript-eslint/no-unsafe-argument */
 import { Decoder } from '@simonbackx/simple-encoding';
 import { DecodedRequest, Endpoint, Request, Response } from '@simonbackx/simple-endpoints';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { Event } from '@stamhoofd/models';
-import { SQL, SQLFilterDefinitions, SQLSortDefinitions, compileToSQLFilter, compileToSQLSorter } from "@stamhoofd/sql";
+import { SQL, SQLFilterDefinitions, SQLSortDefinitions, compileToSQLFilter, compileToSQLSorter } from '@stamhoofd/sql';
 import { CountFilteredRequest, Event as EventStruct, LimitedFilteredRequest, PaginatedResponse, StamhoofdFilter, assertSort, getSortFilter } from '@stamhoofd/structures';
 import { AuthenticatedStructures } from '../../../helpers/AuthenticatedStructures';
@@ -14,20 +13,20 @@ import { eventSorters } from '../../../sql-sorters/events';
 type Params = Record<string, never>;
 type Query = LimitedFilteredRequest;
 type Body = undefined;
-type ResponseBody = PaginatedResponse<EventStruct[], LimitedFilteredRequest>
+type ResponseBody = PaginatedResponse<EventStruct[], LimitedFilteredRequest>;
-const filterCompilers: SQLFilterDefinitions = eventFilterCompilers
-const sorters: SQLSortDefinitions<Event> = eventSorters
+const filterCompilers: SQLFilterDefinitions = eventFilterCompilers;
+const sorters: SQLSortDefinitions<Event> = eventSorters;
 export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBody> {
-    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>
+    queryDecoder = LimitedFilteredRequest as Decoder<LimitedFilteredRequest>;
     protected doesMatch(request: Request): [true, Params] | [false] {
-        if (request.method != "GET") {
+        if (request.method !== 'GET') {
             return [false];
         }
-        const params = Endpoint.parseParameters(request.url, "/events", {});
+        const params = Endpoint.parseParameters(request.url, '/events', {});
         if (params) {
             return [true, params as Params];
@@ -35,74 +34,74 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
         return [false];
     }
-    static buildQuery(q: CountFilteredRequest|LimitedFilteredRequest) {
-        const organization = Context.organization
-        let scopeFilter: StamhoofdFilter|undefined = undefined;
+    static buildQuery(q: CountFilteredRequest | LimitedFilteredRequest) {
+        const organization = Context.organization;
+        let scopeFilter: StamhoofdFilter | undefined = undefined;
         if (organization) {
             scopeFilter = {
                 $or: [
                     {
-                        organizationId: organization.id
+                        organizationId: organization.id,
                     },
                     {
-                        organizationId: null
-                    }
+                        organizationId: null,
+                    },
                 ],
             };
         }
         const query = SQL
             .select(
-                SQL.wildcard(Event.table)
+                SQL.wildcard(Event.table),
             )
             .from(
-                SQL.table(Event.table)
+                SQL.table(Event.table),
             );
         if (scopeFilter) {
-            query.where(compileToSQLFilter(scopeFilter, filterCompilers))
+            query.where(compileToSQLFilter(scopeFilter, filterCompilers));
         }
         if (q.filter) {
-            query.where(compileToSQLFilter(q.filter, filterCompilers))
+            query.where(compileToSQLFilter(q.filter, filterCompilers));
         }
         if (q.search) {
-            let searchFilter: StamhoofdFilter|null = null
+            let searchFilter: StamhoofdFilter | null = null;
             // todo: detect special search patterns and adjust search filter if needed
             searchFilter = {
                 name: {
-                    $contains: q.search
-                }
-            }
+                    $contains: q.search,
+                },
+            };
             if (searchFilter) {
-                query.where(compileToSQLFilter(searchFilter, filterCompilers))
+                query.where(compileToSQLFilter(searchFilter, filterCompilers));
             }
         }
         if (q instanceof LimitedFilteredRequest) {
             if (q.pageFilter) {
-                query.where(compileToSQLFilter(q.pageFilter, filterCompilers))
+                query.where(compileToSQLFilter(q.pageFilter, filterCompilers));
             }
-            q.sort = assertSort(q.sort, [{key: 'id'}])
-            query.orderBy(compileToSQLSorter(q.sort, sorters))
-            query.limit(q.limit)
+            q.sort = assertSort(q.sort, [{ key: 'id' }]);
+            query.orderBy(compileToSQLSorter(q.sort, sorters));
+            query.limit(q.limit);
         }
-        return query
+        return query;
     }
     static async buildData(requestQuery: LimitedFilteredRequest) {
-        const query = GetEventsEndpoint.buildQuery(requestQuery)
-        const data = await query.fetch()
+        const query = GetEventsEndpoint.buildQuery(requestQuery);
+        const data = await query.fetch();
         const events = Event.fromRows(data, Event.table);
-        let next: LimitedFilteredRequest|undefined;
+        let next: LimitedFilteredRequest | undefined;
         if (events.length >= requestQuery.limit) {
             const lastObject = events[events.length - 1];
@@ -113,8 +112,8 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
                 pageFilter: nextFilter,
                 sort: requestQuery.sort,
                 limit: requestQuery.limit,
-                search: requestQuery.search
-            })
+                search: requestQuery.search,
+            });
             if (JSON.stringify(nextFilter) === JSON.stringify(requestQuery.pageFilter)) {
                 console.error('Found infinite loading loop for', requestQuery);
@@ -124,13 +123,13 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
         return new PaginatedResponse<EventStruct[], LimitedFilteredRequest>({
             results: await AuthenticatedStructures.events(events),
-            next
+            next,
         });
     }
     async handle(request: DecodedRequest<Params, Query, Body>) {
         await Context.setOptionalOrganizationScope();
-        await Context.authenticate()
+        await Context.authenticate();
         const maxLimit = Context.auth.hasSomePlatformAccess() ? 1000 : 100;
@@ -138,20 +137,20 @@ export class GetEventsEndpoint extends Endpoint<Params, Query, Body, ResponseBod
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
-                message: 'Limit can not be more than ' + maxLimit
-            })
+                message: 'Limit can not be more than ' + maxLimit,
+            });
         }
         if (request.query.limit < 1) {
             throw new SimpleError({
                 code: 'invalid_field',
                 field: 'limit',
-                message: 'Limit can not be less than 1'
-            })
+                message: 'Limit can not be less than 1',
+            });
         }
         return new Response(
-            await GetEventsEndpoint.buildData(request.query)
+            await GetEventsEndpoint.buildData(request.query),
         );
     }
 }