@stamhoofd/models 2.39.0 → 2.40.0

package/src/models/StripeCheckoutSession.ts

@@ -1,28 +1,28 @@
-import { column,Model } from "@simonbackx/simple-database";
-import { v4 as uuidv4 } from "uuid";
+import { column, Model } from '@simonbackx/simple-database';
+import { v4 as uuidv4 } from 'uuid';
 
 export class StripeCheckoutSession extends Model {
-    static table = "stripe_checkout_sessions";
+    static table = 'stripe_checkout_sessions';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     paymentId: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     stripeSessionId: string;
 
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     organizationId: string | null = null;
 
     /**
      * For direct charges, this should be set
      */
-    @column({ type: "string", nullable: true })
-    accountId: string|null = null
+    @column({ type: 'string', nullable: true })
+    accountId: string | null = null;
 }

package/src/models/StripePaymentIntent.ts

@@ -1,28 +1,28 @@
-import { column,Model } from "@simonbackx/simple-database";
-import { v4 as uuidv4 } from "uuid";
+import { column, Model } from '@simonbackx/simple-database';
+import { v4 as uuidv4 } from 'uuid';
 
 export class StripePaymentIntent extends Model {
-    static table = "stripe_payment_intents";
+    static table = 'stripe_payment_intents';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     paymentId: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     stripeIntentId: string;
 
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     organizationId: string | null = null;
 
     /**
      * For direct charges, this should be set
      */
-    @column({ type: "string", nullable: true })
-    accountId: string|null = null
+    @column({ type: 'string', nullable: true })
+    accountId: string | null = null;
 }

package/src/models/Ticket.ts

@@ -1,14 +1,14 @@
-import { column, ManyToOneRelation, Model } from "@simonbackx/simple-database";
-import { CartReservedSeat } from "@stamhoofd/structures";
-import basex from "base-x";
-import crypto from "crypto";
-import { v4 as uuidv4 } from "uuid";
+import { column, ManyToOneRelation, Model } from '@simonbackx/simple-database';
+import { CartReservedSeat } from '@stamhoofd/structures';
+import basex from 'base-x';
+import crypto from 'crypto';
+import { v4 as uuidv4 } from 'uuid';
 
 import { Order, Organization, Webshop } from './';
 
 // Note: 0 and O is removed to prevent typing it in wrong
-const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZ'
-const bs58 = basex(ALPHABET)
+const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZ';
+const bs58 = basex(ALPHABET);
 
 async function randomBytes(size: number): Promise<Buffer> {
     return new Promise((resolve, reject) => {
@@ -24,33 +24,32 @@ async function randomBytes(size: number): Promise<Buffer> {
 
 /**
  * Use this method when you don't need access to the items of an order.
- * This avoids the select in the database, saving some bytes in network communication 
+ * This avoids the select in the database, saving some bytes in network communication
  * (especially needed when clients requests all the changed tickets)
  */
 export class Ticket extends Model {
-    static table = "webshop_tickets";
+    static table = 'webshop_tickets';
 
     // Columns
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
     /**
      * Unique per webshop. Used for lookups
      */
-    @column({ type: "string", async beforeSave(value) {
+    @column({ type: 'string', async beforeSave(value) {
         return value ?? bs58.encode(await randomBytes(10));
     } })
-    secret!: string
-
+    secret!: string;
 
-    @column({ foreignKey: Ticket.organization, type: "string" })
+    @column({ foreignKey: Ticket.organization, type: 'string' })
     organizationId: string;
 
-    @column({ foreignKey: Ticket.webshop, type: "string" })
+    @column({ foreignKey: Ticket.webshop, type: 'string' })
     webshopId: string;
 
     /**
@@ -59,76 +58,76 @@ export class Ticket extends Model {
      * The order details should remain private to a ticket holder except for the item details
      * + also the orderID should remain private for the holder (since this provides access via URL, need to add a secret here)
      */
-    @column({ foreignKey: Ticket.order, type: "string" })
-    orderId: string
+    @column({ foreignKey: Ticket.order, type: 'string' })
+    orderId: string;
 
     /**
      * null = whole order
      */
-    @column({ type: "string", nullable: true })
-    itemId: string | null = null
+    @column({ type: 'string', nullable: true })
+    itemId: string | null = null;
 
     /**
      * If multiple items are made for the same product, this contains the index
      */
-    @column({ type: "number" })
-    index = 0
+    @column({ type: 'number' })
+    index = 0;
 
     /**
      * total items with index
      */
-    @column({ type: "number" })
-    total = 0
+    @column({ type: 'number' })
+    total = 0;
 
     /**
      * If multiple items are made for the same product, this contains the index
      */
-    @column({ type: "json", nullable: true, decoder: CartReservedSeat })
-    seat: CartReservedSeat | null = null
+    @column({ type: 'json', nullable: true, decoder: CartReservedSeat })
+    seat: CartReservedSeat | null = null;
 
     /**
      * In case the seat is changed, this contains the first assigned seat
      */
-    @column({ type: "json", nullable: true, decoder: CartReservedSeat })
-    originalSeat: CartReservedSeat | null = null
+    @column({ type: 'json', nullable: true, decoder: CartReservedSeat })
+    originalSeat: CartReservedSeat | 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;
 
     @column({
-        type: "datetime", beforeSave() {
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
+        type: 'datetime', beforeSave() {
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
         },
-        skipUpdate: true
+        skipUpdate: true,
     })
-    updatedAt: Date
+    updatedAt: Date;
 
-    @column({ type: "datetime", nullable: true })
-    deletedAt: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    deletedAt: Date | null = null;
 
-    @column({ type: "datetime", nullable: true })
-    scannedAt: Date | null = null
+    @column({ type: 'datetime', nullable: true })
+    scannedAt: Date | null = null;
 
-    @column({ type: "string", nullable: true })
-    scannedBy: string | null = null
+    @column({ type: 'string', nullable: true })
+    scannedBy: string | null = null;
 
-    static webshop = new ManyToOneRelation(Webshop, "webshop");
-    static order = new ManyToOneRelation(Order, "order");
-    static organization = new ManyToOneRelation(Organization, "organization");
+    static webshop = new ManyToOneRelation(Webshop, 'webshop');
+    static order = new ManyToOneRelation(Order, 'order');
+    static organization = new ManyToOneRelation(Organization, 'organization');
 
     getUrl(this: Ticket & { webshop: Webshop & { organization: Organization } }) {
-        return "https://"+this.webshop.getHost()+"/ticket/"+this.secret
+        return 'https://' + this.webshop.getHost() + '/ticket/' + this.secret;
     }
 
     get isDeleted() {
@@ -140,6 +139,6 @@ export class Ticket extends Model {
             return;
         }
         this.deletedAt = new Date();
-        await this.save()
+        await this.save();
     }
-}
+}

package/src/models/Token.test.ts

@@ -3,11 +3,11 @@ import { Database } from '@simonbackx/simple-database';
 import { OrganizationFactory } from '../factories/OrganizationFactory';
 import { UserFactory } from '../factories/UserFactory';
 import { Organization } from './Organization';
-import { Token } from "./Token";
-import { User } from "./User";
+import { Token } from './Token';
+import { User } from './User';
 
-describe("Model.Token", () => {
-    const existingToken = "ABCDEFG";
+describe('Model.Token', () => {
+    const existingToken = 'ABCDEFG';
     let user: User;
     let organization: Organization;
 
@@ -15,22 +15,22 @@ describe("Model.Token", () => {
         organization = await new OrganizationFactory({}).create();
         user = await new UserFactory({ organization }).create();
 
-        await Database.insert("INSERT INTO " + Token.table + " SET ?", [
+        await Database.insert('INSERT INTO ' + Token.table + ' SET ?', [
             {
                 accessToken: existingToken,
-                refreshToken: "refreshtoken",
+                refreshToken: 'refreshtoken',
 
-                accessTokenValidUntil: "2050-08-29 14:30:15",
-                refreshTokenValidUntil: "2050-08-29 14:30:15",
+                accessTokenValidUntil: '2050-08-29 14:30:15',
+                refreshTokenValidUntil: '2050-08-29 14:30:15',
                 userId: user.id,
                 // = "myPassword"
-                createdAt: "2020-03-29 14:30:15",
-                updatedAt: "2020-03-29 14:30:15",
+                createdAt: '2020-03-29 14:30:15',
+                updatedAt: '2020-03-29 14:30:15',
             },
         ]);
     });
 
-    test("Get token", async () => {
+    test('Get token', async () => {
         const token: any = await Token.getByAccessToken(existingToken);
         expect(token).toBeDefined();
         expect(token).toBeInstanceOf(Token);
@@ -39,7 +39,7 @@ describe("Model.Token", () => {
         expect(token.userId).toEqual(user.id);
     });
 
-    test("Create a token", async () => {
+    test('Create a token', async () => {
         const token = await Token.createToken(user);
         expect(token).toBeDefined();
         if (!token) return;
@@ -63,7 +63,7 @@ describe("Model.Token", () => {
             refreshToken: token.refreshToken,
             userId: token.userId,
             accessTokenValidUntil: token.accessTokenValidUntil,
-            refreshTokenValidUntil: token.refreshTokenValidUntil
+            refreshTokenValidUntil: token.refreshTokenValidUntil,
         });
     });
 });

package/src/models/Token.ts

@@ -1,8 +1,8 @@
-import { column, Database, ManyToOneRelation, Model } from "@simonbackx/simple-database";
-import { ApiUser } from "@stamhoofd/structures";
-import crypto from "crypto";
+import { column, Database, ManyToOneRelation, Model } from '@simonbackx/simple-database';
+import { ApiUser } from '@stamhoofd/structures';
+import crypto from 'crypto';
 
-import { RateLimiter } from "../helpers/RateLimiter";
+import { RateLimiter } from '../helpers/RateLimiter';
 import { User } from './';
 
 export type TokenWithUser = Token & { user: User };
@@ -21,85 +21,85 @@ async function randomBytes(size: number): Promise<Buffer> {
 
 export const apiUserRateLimiter = new RateLimiter({
     limits: [
-        {   
+        {
             // Block heavy bursts (5req/s for 5s)
             limit: 25,
-            duration: 5 * 1000
+            duration: 5 * 1000,
         },
-        {   
+        {
             // max 1req/s during 150s
             limit: 150,
-            duration: 150 * 1000
+            duration: 150 * 1000,
         },
-        {   
+        {
             // 1000 requests per hour
             limit: 1000,
-            duration: 60 * 1000 * 60
+            duration: 60 * 1000 * 60,
         },
-        {   
+        {
             // 2000 requests per day
             limit: 2000,
-            duration: 24 * 60 * 1000 * 60
-        }
-    ]
+            duration: 24 * 60 * 1000 * 60,
+        },
+    ],
 });
 
 export class Token extends Model {
-    static table = "tokens";
+    static table = 'tokens';
     static MAX_DEVICES = 15;
 
-    @column({ type: "string", foreignKey: Token.user })
+    @column({ type: 'string', foreignKey: Token.user })
     userId: string;
 
     // Columns
-    @column({ primary: true, type: "string" })
+    @column({ primary: true, type: 'string' })
     accessToken: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     refreshToken: string;
 
-    @column({ type: "datetime" })
+    @column({ type: 'datetime' })
     accessTokenValidUntil: Date;
 
-    @column({ type: "datetime" })
+    @column({ type: 'datetime' })
     refreshTokenValidUntil: 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;
 
     @column({
-        type: "datetime", beforeSave() {
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
+        type: 'datetime', beforeSave() {
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
         },
-        skipUpdate: true
+        skipUpdate: true,
     })
-    updatedAt: Date
+    updatedAt: Date;
 
-    static user = new ManyToOneRelation(User, "user");
+    static user = new ManyToOneRelation(User, 'user');
 
     isAccessTokenExpired(): boolean {
-        return this.accessTokenValidUntil < new Date() || this.refreshTokenValidUntil < new Date()
+        return this.accessTokenValidUntil < new Date() || this.refreshTokenValidUntil < new Date();
     }
 
     static async getAPIUserWithToken(user: User) {
         if (!user.isApiUser) {
-            throw new Error('Unexpected user type')
+            throw new Error('Unexpected user type');
         }
 
         const [lastToken] = await this.where({
-            userId: user.id
-        }, {limit: 1})
+            userId: user.id,
+        }, { limit: 1 });
 
         return ApiUser.create({
             id: user.id,
@@ -108,7 +108,7 @@ export class Token extends Model {
             permissions: user.permissions,
             expiresAt: lastToken?.accessTokenValidUntil ?? null,
             createdAt: user.createdAt,
-        })
+        });
     }
 
     /**
@@ -118,8 +118,8 @@ export class Token extends Model {
         const [rows] = await Database.select(
             `SELECT ${this.getDefaultSelect()}, user.*  FROM ${
                 this.table
-            } ${Token.user.joinQuery(this.table, "user")} WHERE ${this.primary.name} = ? LIMIT 1 `,
-            [accessToken]
+            } ${Token.user.joinQuery(this.table, 'user')} WHERE ${this.primary.name} = ? LIMIT 1 `,
+            [accessToken],
         );
 
         if (rows.length == 0) {
@@ -135,13 +135,13 @@ export class Token extends Model {
 
         if (!ignoreExpireDate && (token.accessTokenValidUntil < new Date() || token.refreshTokenValidUntil < new Date())) {
             // Also if the refresh token is invalid, the access token will always be invalid
-            return undefined
+            return undefined;
         }
 
-        const user = User.fromRow(rows[0]["user"]) || null;
+        const user = User.fromRow(rows[0]['user']) || null;
 
         if (!user) {
-            console.warn("Selected a token without a user!");
+            console.warn('Selected a token without a user!');
             return undefined;
         }
 
@@ -151,10 +151,10 @@ export class Token extends Model {
     // Methods
     static async getByRefreshToken(refreshToken: string): Promise<TokenWithUser | undefined> {
         const [rows] = await Database.select(
-            `SELECT ${this.getDefaultSelect()}, ${User.getDefaultSelect("user")}  FROM ${
-            this.table
-            } ${Token.user.joinQuery(this.table, "user")} WHERE \`refreshToken\` = ? LIMIT 1 `,
-            [refreshToken]
+            `SELECT ${this.getDefaultSelect()}, ${User.getDefaultSelect('user')}  FROM ${
+                this.table
+            } ${Token.user.joinQuery(this.table, 'user')} WHERE \`refreshToken\` = ? LIMIT 1 `,
+            [refreshToken],
         );
 
         if (rows.length == 0) {
@@ -170,16 +170,16 @@ export class Token extends Model {
 
         if (token.refreshTokenValidUntil < new Date()) {
             // Refreh token invalid = can throw it away
-            token.delete().catch(e => {
-                console.error(e)
-            })
-            return undefined
+            token.delete().catch((e) => {
+                console.error(e);
+            });
+            return undefined;
         }
 
-        const user = User.fromRow(rows[0]["user"]) || null;
+        const user = User.fromRow(rows[0]['user']) || null;
 
         if (!user || user.isApiUser) {
-            console.warn("Selected a token without a user!");
+            console.warn('Selected a token without a user!');
             return undefined;
         }
 
@@ -189,13 +189,13 @@ export class Token extends Model {
     /**
      * Create a token that is expired. This can be usefull if renewing the token is restricted by some account state.
      * E.g. you cannot renew this token until the e-mail address has been verified.
-     * @param user 
+     * @param user
      */
     static async createExpiredToken<U extends User>(user: U): Promise<(Token & { user: U })> {
         const token = await this.createUnsavedToken(user);
 
         /// Expired a month ago (to prevent any timezone bugs)
-        token.accessTokenValidUntil = new Date(Date.now() - 24 * 60 * 60 * 1000 * 31 );
+        token.accessTokenValidUntil = new Date(Date.now() - 24 * 60 * 60 * 1000 * 31);
         token.accessTokenValidUntil.setMilliseconds(0);
 
         await token.save();
@@ -215,17 +215,18 @@ export class Token extends Model {
                 rows,
             ] = await Database.delete(
                 `DELETE FROM \`${this.table}\` WHERE ${this.primary.name} IN (SELECT ${this.primary.name} FROM (SELECT ${this.primary.name} FROM \`${this.table}\` WHERE \`userId\` = ? ORDER BY\`refreshTokenValidUntil\` DESC LIMIT ? OFFSET ?) x)`,
-                [user.id, this.MAX_DEVICES, this.MAX_DEVICES]
+                [user.id, this.MAX_DEVICES, this.MAX_DEVICES],
             );
 
             if (rows.affectedRows > 0) {
                 console.log(`Deleted ${rows.affectedRows} old tokens first`);
             }
-        } catch (e) {
+        }
+        catch (e) {
             // This is not a crucial operation, so don't fail when there is a deadlock problem in the query
-            console.error(e)
+            console.error(e);
         }
-        
+
         const token = new Token().setRelation(Token.user, user);
         token.accessTokenValidUntil = new Date();
         token.accessTokenValidUntil.setTime(token.accessTokenValidUntil.getTime() + 3600 * 1000);
@@ -235,8 +236,8 @@ export class Token extends Model {
         token.refreshTokenValidUntil.setTime(token.refreshTokenValidUntil.getTime() + 3600 * 1000 * 24 * 365);
         token.refreshTokenValidUntil.setMilliseconds(0);
 
-        token.accessToken = (await randomBytes(192)).toString("base64").toUpperCase();
-        token.refreshToken = (await randomBytes(192)).toString("base64").toUpperCase();
+        token.accessToken = (await randomBytes(192)).toString('base64').toUpperCase();
+        token.refreshToken = (await randomBytes(192)).toString('base64').toUpperCase();
         return token;
     }
 
@@ -248,7 +249,7 @@ export class Token extends Model {
 
     static async createApiToken<U extends User>(user: U): Promise<(Token & { user: U })> {
         const token = await this.createUnsavedToken(user);
-        
+
         // 5 year valid
         token.accessTokenValidUntil = new Date();
         token.accessTokenValidUntil.setTime(token.accessTokenValidUntil.getTime() + 1000 * 60 * 60 * 24 * 365 * 5);
@@ -264,6 +265,6 @@ export class Token extends Model {
 
     static async clearFor(userId: string, currentToken: string) {
         const query = `DELETE from ${this.table} where userId = ? AND accessToken != ?`;
-        await Database.delete(query, [userId, currentToken])
+        await Database.delete(query, [userId, currentToken]);
     }
 }

package/src/models/UsedRegisterCode.ts

@@ -1,51 +1,50 @@
-import { column, Model } from "@simonbackx/simple-database";
-import { v4 as uuidv4 } from "uuid";
-
+import { column, Model } from '@simonbackx/simple-database';
+import { v4 as uuidv4 } from 'uuid';
 
 export class UsedRegisterCode extends Model {
-    static table = "used_register_codes";
+    static table = 'used_register_codes';
 
     @column({
-        primary: true, type: "string", beforeSave(value) {
+        primary: true, type: 'string', beforeSave(value) {
             return value ?? uuidv4();
-        }
+        },
     })
     id!: string;
 
-    @column({ type: "string" })
+    @column({ type: 'string' })
     code: string;
 
     /**
      * Code is used by...
      */
-    @column({ type: "string" })
+    @column({ type: 'string' })
     organizationId: string;
 
     /**
      * Set if this has been rewarded
      */
-    @column({ type: "string", nullable: true })
+    @column({ type: 'string', nullable: true })
     creditId: string | 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;
 
     @column({
-        type: "datetime", beforeSave() {
-            const date = new Date()
-            date.setMilliseconds(0)
-            return date
+        type: 'datetime', beforeSave() {
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
         },
-        skipUpdate: true
+        skipUpdate: true,
     })
-    updatedAt: Date
+    updatedAt: Date;
 }