@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/MollieToken.ts

@@ -1,9 +1,9 @@
-import { column,Model } from '@simonbackx/simple-database';
+import { column, Model } from '@simonbackx/simple-database';
 import { PartialWithoutMethods, PlainObject } from '@simonbackx/simple-encoding';
 import { SimpleError } from '@simonbackx/simple-errors';
-import { MollieOnboarding,MollieProfile, MollieStatus } from '@stamhoofd/structures';
-import { IncomingMessage } from "http";
-import https from "https";
+import { MollieOnboarding, MollieProfile, MollieStatus } from '@stamhoofd/structures';
+import { IncomingMessage } from 'http';
+import https from 'https';
 
 import { Organization } from './Organization';
 
@@ -12,117 +12,119 @@ function sleep(ms: number) {
 }
 
 export class MollieToken extends Model {
-    static table = "mollie_tokens"
+    static table = 'mollie_tokens';
 
-    @column({ primary: true, type: "string" })
+    @column({ primary: true, type: 'string' })
     organizationId!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     accessToken: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     refreshToken: string;
 
-    @column({ type: "datetime" })
+    @column({ type: 'datetime' })
     expiresOn: Date;
 
     @column({
-        type: "datetime", beforeSave(old?: any) {
+        type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
                 return old;
             }
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
-        }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
     })
-    createdAt: Date
+    createdAt: Date;
 
-    static verbose = true
+    static verbose = true;
 
-    static knownTokens: Map<string, MollieToken> = new Map()
+    static knownTokens: Map<string, MollieToken> = new Map();
 
     static async getTokenFor(organizationId: string) {
-        const existing = this.knownTokens.get(organizationId)
+        const existing = this.knownTokens.get(organizationId);
         if (existing) {
-            return existing
+            return existing;
         }
-        const tokens = await MollieToken.where({ organizationId })
+        const tokens = await MollieToken.where({ organizationId });
         if (tokens.length == 0) {
-            return undefined
+            return undefined;
         }
-        this.knownTokens.set(organizationId, tokens[0])
-        return tokens[0]
+        this.knownTokens.set(organizationId, tokens[0]);
+        return tokens[0];
     }
 
     async delete() {
-        await super.delete()
-        MollieToken.knownTokens.delete(this.organizationId)
+        await super.delete();
+        MollieToken.knownTokens.delete(this.organizationId);
     }
 
     private static objectToQueryString(obj: Record<string, string>) {
         const str: string[] = [];
-        // eslint-disable-next-line no-prototype-builtins
+
         for (const p in obj)
             // eslint-disable-next-line no-prototype-builtins
             if (obj.hasOwnProperty(p)) {
-                str.push(encodeURIComponent(p) + "=" + encodeURIComponent(obj[p]));
+                str.push(encodeURIComponent(p) + '=' + encodeURIComponent(obj[p]));
             }
-        return str.join("&");
+        return str.join('&');
     }
 
     async getAccessToken() {
         if (this.expiresOn < new Date()) {
-            await this.refresh()
-            await sleep(200)
+            await this.refresh();
+            await sleep(200);
         }
-        return this.accessToken
+        return this.accessToken;
     }
 
     async refreshIfNeeded() {
         if (this.expiresOn < new Date()) {
-            await this.refresh()
-            await sleep(200)
+            await this.refresh();
+            await sleep(200);
         }
     }
 
     async authRequest(method: string, path: string, data: PlainObject = {}) {
         if (this.expiresOn < new Date()) {
-            await this.refresh()
-            await sleep(200)
+            await this.refresh();
+            await sleep(200);
         }
 
-        return await MollieToken.request(method, path, data, "json", this.accessToken);
+        return await MollieToken.request(method, path, data, 'json', this.accessToken);
     }
 
     /**
      * Do a post request on the API.
      */
-    private static request(method: string, path: string, data: PlainObject = {}, type = "json", auth: string | null = null): Promise<any> {
+    private static request(method: string, path: string, data: PlainObject = {}, type = 'json', auth: string | null = null): Promise<any> {
         return new Promise((resolve, reject) => {
             let jsonData: string;
-            if (type == "json") {
+            if (type == 'json') {
                 jsonData = JSON.stringify(data);
-            } else {
+            }
+            else {
                 jsonData = this.objectToQueryString(data as Record<string, string>);
             }
 
             if (this.verbose) {
-                console.log(method+" https://api.mollie.com"+path+"\n"+jsonData);
+                console.log(method + ' https://api.mollie.com' + path + '\n' + jsonData);
             }
             const req = https.request(
                 {
-                    hostname: "api.mollie.com",
+                    hostname: 'api.mollie.com',
                     path: path,
                     method: method,
-                    headers: method === 'GET' ? 
-                    {
-                        "Authorization": auth ? "Bearer "+auth : "Basic "+Buffer.from((STAMHOOFD.MOLLIE_CLIENT_ID ?? "")+":"+(STAMHOOFD.MOLLIE_SECRET ?? ""), "ascii").toString("base64")
-                    } : {
-                        "Content-Type": type == "json" ? "application/json" : "application/x-www-form-urlencoded",
-                        "Content-Length": Buffer.byteLength(jsonData),
-                        "Authorization": auth ? "Bearer "+auth : "Basic "+Buffer.from((STAMHOOFD.MOLLIE_CLIENT_ID ?? "")+":"+(STAMHOOFD.MOLLIE_SECRET ?? ""), "ascii").toString("base64")
-                    },
+                    headers: method === 'GET'
+                        ? {
+                                Authorization: auth ? 'Bearer ' + auth : 'Basic ' + Buffer.from((STAMHOOFD.MOLLIE_CLIENT_ID ?? '') + ':' + (STAMHOOFD.MOLLIE_SECRET ?? ''), 'ascii').toString('base64'),
+                            }
+                        : {
+                                'Content-Type': type == 'json' ? 'application/json' : 'application/x-www-form-urlencoded',
+                                'Content-Length': Buffer.byteLength(jsonData),
+                                'Authorization': auth ? 'Bearer ' + auth : 'Basic ' + Buffer.from((STAMHOOFD.MOLLIE_CLIENT_ID ?? '') + ':' + (STAMHOOFD.MOLLIE_SECRET ?? ''), 'ascii').toString('base64'),
+                            },
                     timeout: 10000,
                 },
                 (response: IncomingMessage) => {
@@ -133,14 +135,14 @@ export class MollieToken extends Model {
 
                     const chunks: any[] = [];
 
-                    response.on("data", (chunk) => {
+                    response.on('data', (chunk) => {
                         chunks.push(chunk);
                     });
 
-                    response.on("end", () => {
+                    response.on('end', () => {
                         try {
                             if (!response.statusCode) {
-                                reject(new Error("Unexpected order of events"));
+                                reject(new Error('Unexpected order of events'));
                                 return;
                             }
                             const body = Buffer.concat(chunks).toString();
@@ -151,26 +153,28 @@ export class MollieToken extends Model {
 
                             if (response.statusCode == 204) {
                                 resolve(undefined);
-                                return
+                                return;
                             }
 
                             let json: any;
                             try {
                                 json = JSON.parse(body);
-                            } catch (error) {
+                            }
+                            catch (error) {
                                 console.error(error);
-                                
+
                                 // invalid json
                                 if (response.statusCode < 200 || response.statusCode >= 300) {
                                     if (body.length == 0) {
                                         console.error(response.statusCode);
-                                        reject(new Error("Status " + response.statusCode));
+                                        reject(new Error('Status ' + response.statusCode));
                                         return;
                                     }
-                                    console.error(response.statusCode + " " + body);
+                                    console.error(response.statusCode + ' ' + body);
                                     reject(new Error(body));
                                     return;
-                                } else {
+                                }
+                                else {
                                     // something wrong: throw parse error
                                     reject(error);
                                     return;
@@ -179,27 +183,28 @@ export class MollieToken extends Model {
 
                             if (response.statusCode < 200 || response.statusCode >= 300) {
                                 console.error(body);
-                                reject(new Error(response.statusCode + " " + response.statusMessage));
+                                reject(new Error(response.statusCode + ' ' + response.statusMessage));
                                 return;
                             }
 
                             resolve(json);
-                        } catch (error) {
+                        }
+                        catch (error) {
                             if (this.verbose) {
                                 console.error(error);
                             }
                             reject(error);
                         }
                     });
-                }
+                },
             );
 
             // use its "timeout" event to abort the request
-            req.on("timeout", () => {
+            req.on('timeout', () => {
                 req.abort();
             });
 
-            req.on("error", (error) => {
+            req.on('error', (error) => {
                 if (this.verbose) {
                     console.error(error);
                 }
@@ -217,24 +222,23 @@ export class MollieToken extends Model {
     * Refresh the token itself, without generating a new token. Everyone who had the token has a new token now
     */
     async refresh(): Promise<void> {
-        const data = await MollieToken.request("POST", "/oauth2/tokens", {
-            grant_type: "refresh_token",
+        const data = await MollieToken.request('POST', '/oauth2/tokens', {
+            grant_type: 'refresh_token',
             refresh_token: this.refreshToken,
-        }, "urlencoded")
+        }, 'urlencoded');
 
         if (data && data.access_token && data.refresh_token) {
             // Delete token if exisitng
-            this.refreshToken = data.refresh_token
-            this.accessToken = data.access_token
-            this.expiresOn = new Date(new Date().getTime() + 3600 * 1000 - 60*1000)
-            await this.save()
+            this.refreshToken = data.refresh_token;
+            this.accessToken = data.access_token;
+            this.expiresOn = new Date(new Date().getTime() + 3600 * 1000 - 60 * 1000);
+            await this.save();
 
             // Update shared tokens if this object was fetched directly
-            MollieToken.knownTokens.set(this.organizationId, this)
-            return
+            MollieToken.knownTokens.set(this.organizationId, this);
+            return;
         }
-        throw new SimpleError({ code: "", message: "Something went wrong in the response"})
-
+        throw new SimpleError({ code: '', message: 'Something went wrong in the response' });
     }
 
     /**
@@ -242,100 +246,101 @@ export class MollieToken extends Model {
     */
     async revoke(): Promise<void> {
         try {
-            await MollieToken.request("DELETE", "/oauth2/tokens", {
-                token_type_hint: "refresh_token",
+            await MollieToken.request('DELETE', '/oauth2/tokens', {
+                token_type_hint: 'refresh_token',
                 token: this.refreshToken,
-            }, "urlencoded")
-        } catch (e) {
-            console.error("Failed to revoke token", this.organizationId, e)
+            }, 'urlencoded');
+        }
+        catch (e) {
+            console.error('Failed to revoke token', this.organizationId, e);
         }
-        await this.delete()
+        await this.delete();
     }
 
     /**
     * Refresh the token itself, without generating a new token. Everyone who had the token has a new token now
     */
     static async create(organization: Organization, code: string): Promise<MollieToken> {
-        const data = await MollieToken.request("POST", "/oauth2/tokens", {
-            grant_type: "authorization_code",
-            code: code
-        }, "urlencoded")
+        const data = await MollieToken.request('POST', '/oauth2/tokens', {
+            grant_type: 'authorization_code',
+            code: code,
+        }, 'urlencoded');
 
         if (data && data.access_token && data.refresh_token) {
             // Delete token if exisitng
-            const existing = await MollieToken.where({ organizationId: organization.id })
-            const token = existing[0] ?? new MollieToken()
-            token.organizationId = organization.id
-            token.refreshToken = data.refresh_token
-            token.accessToken = data.access_token
-            token.expiresOn = new Date(new Date().getTime() + 3600 * 1000 - 60*1000)
-            await token.save()
+            const existing = await MollieToken.where({ organizationId: organization.id });
+            const token = existing[0] ?? new MollieToken();
+            token.organizationId = organization.id;
+            token.refreshToken = data.refresh_token;
+            token.accessToken = data.access_token;
+            token.expiresOn = new Date(new Date().getTime() + 3600 * 1000 - 60 * 1000);
+            await token.save();
 
-            this.knownTokens.set(organization.id, token)
+            this.knownTokens.set(organization.id, token);
 
-            organization.privateMeta.mollieOnboarding = await token.getOnboardingStatus()
-            await token.setup(organization)
+            organization.privateMeta.mollieOnboarding = await token.getOnboardingStatus();
+            await token.setup(organization);
 
-            await organization.save()
-            return token
+            await organization.save();
+            return token;
         }
-        throw new SimpleError({ code: "", message: "Something went wrong in the response"})
-
+        throw new SimpleError({ code: '', message: 'Something went wrong in the response' });
     }
 
     async getOnboardingStatus() {
         try {
-            const response = await this.authRequest("GET", "/v2/onboarding/me")
+            const response = await this.authRequest('GET', '/v2/onboarding/me');
             return MollieOnboarding.create({
                 canReceivePayments: !!response.canReceivePayments,
                 canReceiveSettlements: !!response.canReceiveSettlements,
-                status: response.status === "needs-data" ? MollieStatus.NeedsData : (response.status === "in-review" ? MollieStatus.InReview : (MollieStatus.Completed))
+                status: response.status === 'needs-data' ? MollieStatus.NeedsData : (response.status === 'in-review' ? MollieStatus.InReview : (MollieStatus.Completed)),
             });
-        } catch (e) {
-            console.error("Error when requesting Mollie onboarding status:")
-            console.error(e)
+        }
+        catch (e) {
+            console.error('Error when requesting Mollie onboarding status:');
+            console.error(e);
             return null;
         }
     }
 
     async getProfiles(): Promise<MollieProfile[]> {
         try {
-            const response = await this.authRequest("GET", "/v2/profiles?limit=250")
+            const response = await this.authRequest('GET', '/v2/profiles?limit=250');
             const profiles = response._embedded.profiles as PartialWithoutMethods<MollieProfile>[];
-            return profiles.map(p => MollieProfile.create(p))
-        } catch(e) {
-            console.error('Failed to parse mollie profiles', e)
+            return profiles.map(p => MollieProfile.create(p));
+        }
+        catch (e) {
+            console.error('Failed to parse mollie profiles', e);
             return [];
         }
     }
 
     async getProfileId(website?: string): Promise<string | null> {
-        const response = await this.authRequest("GET", "/v2/profiles?limit=250")
+        const response = await this.authRequest('GET', '/v2/profiles?limit=250');
         const profiles = response._embedded.profiles;
 
         // Search profile with Stamhoofd as name
         if (website) {
             for (const profile of profiles) {
                 if (profile.website.toLowerCase().includes(website)) {
-                    return profile.id
+                    return profile.id;
                 }
             }
         }
 
         // Search profile with Stamhoofd as name
         for (const profile of profiles) {
-            if (profile.name.toLowerCase().includes("stamhoofd")) {
-                return profile.id
+            if (profile.name.toLowerCase().includes('stamhoofd')) {
+                return profile.id;
             }
         }
 
-        return response._embedded.profiles[0]?.id ?? null
-
+        return response._embedded.profiles[0]?.id ?? null;
     }
 
     async getOnboardingLink() {
-        const response = await this.authRequest("GET", "/v2/onboarding/me")
-        return response._links.dashboard.href ?? ""
+        const response = await this.authRequest('GET', '/v2/onboarding/me');
+        return response._links.dashboard.href ?? '';
     }
 
     /**
@@ -345,25 +350,25 @@ export class MollieToken extends Model {
         // Submit onboarding data
 
         if (organization.privateMeta.mollieOnboarding && organization.privateMeta.mollieOnboarding.status == MollieStatus.NeedsData) {
-            await this.authRequest("POST", "/v2/onboarding/me", {
+            await this.authRequest('POST', '/v2/onboarding/me', {
                 organization: {
                     name: organization.name,
                     address: {
-                        streetAndNumber: organization.address.street + " "+organization.address.number,
+                        streetAndNumber: organization.address.street + ' ' + organization.address.number,
                         postalCode: organization.address.postalCode,
                         city: organization.address.city,
                         country: organization.address.country,
                     },
-                   
-                    vatRegulation: "shifted"
+
+                    vatRegulation: 'shifted',
                 },
                 profile: {
-                    name: organization.name+" - Stamhoofd",
-                    //url: "https://"+organization.getHost(),
-                    description: "Betalen van inschrijvingsgelden of webshops voor een vereniging via Stamhoofd (partner).",
-                    categoryCode: 8398
-                }
-            })
+                    name: organization.name + ' - Stamhoofd',
+                    // url: "https://"+organization.getHost(),
+                    description: 'Betalen van inschrijvingsgelden of webshops voor een vereniging via Stamhoofd (partner).',
+                    categoryCode: 8398,
+                },
+            });
         }
     }
-}
+}

package/src/models/OneTimeToken.ts

@@ -1,13 +1,12 @@
+import { column, Model } from '@simonbackx/simple-database';
+import { AnyDecoder } from '@simonbackx/simple-encoding';
+import basex from 'base-x';
+import crypto from 'crypto';
 
-import { column, Model } from "@simonbackx/simple-database";
-import { AnyDecoder } from "@simonbackx/simple-encoding";
-import basex from "base-x";
-import crypto from "crypto";
+import { Organization } from './Organization';
 
-import { Organization } from "./Organization";
-
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-const bs58 = basex(ALPHABET)
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
+const bs58 = basex(ALPHABET);
 
 async function randomBytes(size: number): Promise<Buffer> {
     return new Promise((resolve, reject) => {
@@ -22,57 +21,57 @@ async function randomBytes(size: number): Promise<Buffer> {
 }
 
 enum OneTimeTokenType {
-    WebshopNotificationEmailVerification = "WebshopNotificationEmailVerification",
-    WebshopNotificationEmailUnsubscribe = "WebshopNotificationEmailUnsubscribe"
+    WebshopNotificationEmailVerification = 'WebshopNotificationEmailVerification',
+    WebshopNotificationEmailUnsubscribe = 'WebshopNotificationEmailUnsubscribe',
 }
 
 /**
  * Token that saves some information and can execute an action if you have access to the token (e.g. in an email)
  */
 export class OneTimeToken extends Model {
-    static table = "one_time_tokens";
-   
+    static table = 'one_time_tokens';
+
     // Columns
-    @column({ primary: true, type: "string" })
+    @column({ primary: true, type: 'string' })
     token: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     organizationId: string;
 
-    @column({ type: "datetime", nullable: true })
+    @column({ type: 'datetime', nullable: true })
     validUntil: Date | null = null;
 
     @column({
-        type: "datetime", beforeSave(old?: any) {
+        type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
                 return old;
             }
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
-        }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
     })
-    createdAt: Date
+    createdAt: Date;
 
     // Columns
-    @column({ type: "string" })
-    type: OneTimeTokenType
+    @column({ type: 'string' })
+    type: OneTimeTokenType;
 
     // Columns
-    @column({ type: "json", decoder: AnyDecoder })
+    @column({ type: 'json', decoder: AnyDecoder })
     data: any = {};
 
     isExpired(): boolean {
-        return !!this.validUntil && this.validUntil < new Date()
+        return !!this.validUntil && this.validUntil < new Date();
     }
-    
+
     /**
      * Get a token
-     * @param token 
+     * @param token
      * @param ignoreExpireDate: do not return if it is expired
      */
     static async getToken(token: string, organizationId: string, ignoreExpireDate = false): Promise<OneTimeToken | undefined> {
-        const [oneTimeToken] = await this.where({token, organizationId}, {limit: 1})
+        const [oneTimeToken] = await this.where({ token, organizationId }, { limit: 1 });
 
         if (!oneTimeToken) {
             return undefined;
@@ -80,7 +79,7 @@ export class OneTimeToken extends Model {
 
         if (!ignoreExpireDate && oneTimeToken.isExpired()) {
             // If the refresh token is invalid, do not return it
-            return undefined
+            return undefined;
         }
 
         return oneTimeToken;
@@ -89,16 +88,17 @@ export class OneTimeToken extends Model {
     /***
      * Create a token without saving it
      */
-    static async createToken(organizationId: string, type: OneTimeTokenType, data: any, options?: {validUntil?: Date, expireIn?: number}): Promise<OneTimeToken> {
+    static async createToken(organizationId: string, type: OneTimeTokenType, data: any, options?: { validUntil?: Date; expireIn?: number }): Promise<OneTimeToken> {
         const token = new OneTimeToken();
         token.type = type;
         token.data = data;
-        token.organizationId = organizationId
+        token.organizationId = organizationId;
 
         if (options?.validUntil) {
-            token.validUntil = new Date(options?.validUntil)
+            token.validUntil = new Date(options?.validUntil);
             token.validUntil.setMilliseconds(0);
-        } else if (options?.expireIn) {
+        }
+        else if (options?.expireIn) {
             token.validUntil = new Date();
             token.validUntil.setTime(token.validUntil.getTime() + options?.expireIn);
             token.validUntil.setMilliseconds(0);
@@ -117,15 +117,16 @@ export class OneTimeToken extends Model {
 
         let host: string;
         if (dashboard) {
-            host = "https://"+(STAMHOOFD.domains.dashboard ?? "stamhoofd.app")+"/"+i18n.locale
-        } else {
-            host = "https://"+organization.getHost()
+            host = 'https://' + (STAMHOOFD.domains.dashboard ?? 'stamhoofd.app') + '/' + i18n.locale;
+        }
+        else {
+            host = 'https://' + organization.getHost();
 
-            if (i18n.language != organization.i18n.language) {
-                host += "/"+i18n.language
+            if (i18n.language !== organization.i18n.language) {
+                host += '/' + i18n.language;
             }
         }
 
-        return host+"/ott"+(dashboard ? "/"+encodeURIComponent(organization.id) : "")+"?token="+encodeURIComponent(this.token);
+        return host + '/ott' + (dashboard ? '/' + encodeURIComponent(organization.id) : '') + '?token=' + encodeURIComponent(this.token);
     }
 }