@stamhoofd/models 2.5.0 → 2.7.0

package/src/models/Group.ts

@@ -1,9 +1,11 @@
 import { column, Database, ManyToOneRelation, Model, OneToManyRelation } from '@simonbackx/simple-database';
-import { GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType } from '@stamhoofd/structures';
+import { GroupCategory, GroupPrivateSettings, GroupSettings, GroupStatus, Group as GroupStruct, GroupType, StockReservation } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from "uuid";
 
 import { Formatter } from '@stamhoofd/utility';
 import { Member, MemberWithRegistrations, OrganizationRegistrationPeriod, Payment, Registration, User } from './';
+import { QueueHandler } from '@stamhoofd/queues';
+import { ArrayDecoder } from '@simonbackx/simple-encoding';
 
 if (Member === undefined) {
     throw new Error("Import Member is undefined")
@@ -85,17 +87,20 @@ export class Group extends Model {
     })
     deletedAt: Date | null = null
 
-    /**
-     * Every time a new registration period starts, this number increases. This is used to mark all older registrations as 'out of date' automatically
-     */
     @column({ type: "string" })
     status = GroupStatus.Open;
 
+    /**
+     * Editing this field is only allowed when running inside the QueueHandler
+     */
+    @column({ type: "json", decoder: new ArrayDecoder(StockReservation) })
+    stockReservations: StockReservation[] = []
+
     static async getAll(organizationId: string, periodId: string|null, active = true) {
         const w: any = periodId ? {periodId} : {}
         if (active) {
             // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
-            return await Group.where({ organizationId, deletedAt: null, ...w, status: {sign: '!=', value: GroupStatus.Archived} })
+            return await Group.where({ organizationId, deletedAt: null, ...w })
         }
         // eslint-disable-next-line @typescript-eslint/no-unsafe-argument
         return await Group.where({ organizationId, ...w })
@@ -216,18 +221,13 @@ export class Group extends Model {
 
     async updateOccupancy() {
         this.settings.registeredMembers = await Group.getCount(
-            "groupId = ? and cycle = ? and waitingList = 0 and registeredAt is not null",
-            [this.id, this.cycle]
+            "groupId = ? and registeredAt is not null AND deactivatedAt is null",
+            [this.id]
         )
 
         this.settings.reservedMembers = await Group.getCount(
-            "groupId = ? and cycle = ? and ((waitingList = 0 and registeredAt is null AND reservedUntil >= ?) OR (waitingList = 1 and canRegister = 1))",
-            [this.id, this.cycle, new Date()]
-        )
-
-        this.settings.waitingListSize = await Group.getCount(
-            "groupId = ? and cycle = ? and waitingList = 1",
-            [this.id, this.cycle, new Date()]
+            "groupId = ? and registeredAt is null AND (canRegister = 1 OR reservedUntil >= ?)",
+            [this.id, new Date()]
         )
     }
 
@@ -280,6 +280,28 @@ export class Group extends Model {
         }
     }
 
+    static async applyStockReservations(groupId: string, addStockReservations: StockReservation[], free = false) {
+        await QueueHandler.schedule('group-stock-update-'+groupId, async () => {
+            const updatedGroup = await Group.getByID(groupId)
+            if (!updatedGroup) {
+                throw new Error("Expected group")
+            }
+
+            if (!free) {
+                updatedGroup.stockReservations = StockReservation.added(updatedGroup.stockReservations, addStockReservations)
+            } else {
+                updatedGroup.stockReservations = StockReservation.removed(updatedGroup.stockReservations, addStockReservations)
+            }
+            await updatedGroup.save()
+        })
+
+    }
+
+    static async freeStockReservations(groupId: string, reservations: StockReservation[]) {
+        return await this.applyStockReservations(groupId, reservations, true)
+    }
+
+
 }
 
 Registration.group = new ManyToOneRelation(Group, "group")

package/src/models/Member.ts

@@ -1,11 +1,11 @@
 import { column, Database, ManyToManyRelation, ManyToOneRelation, Model, OneToManyRelation } from '@simonbackx/simple-database';
 import { SQL } from "@stamhoofd/sql";
-import { Member as MemberStruct, MemberDetails, MemberWithRegistrationsBlob, RegistrationWithMember as RegistrationWithMemberStruct, User as UserStruct, GroupStatus } from '@stamhoofd/structures';
+import { MemberDetails, MemberWithRegistrationsBlob, RegistrationWithMember as RegistrationWithMemberStruct, TinyMember } from '@stamhoofd/structures';
 import { Formatter, Sorter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from "uuid";
 
-import { Group, MemberPlatformMembership, Payment, Platform, Registration, User } from './';
 import { QueueHandler } from '@stamhoofd/queues';
+import { Group, MemberPlatformMembership, Payment, Platform, Registration, User } from './';
 export type MemberWithRegistrations = Member & { 
     users: User[], 
     registrations: (Registration & {group: Group})[] 
@@ -144,7 +144,7 @@ export class Member extends Model {
         }
         let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()} from \`${Member.table}\`\n`;
         
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`
+        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`canRegister\` = 1)\n`
 
         // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
         query += `where \`${Registration.table}\`.\`${Registration.primary.name}\` IN (?)`
@@ -177,15 +177,15 @@ export class Member extends Model {
     /**
      * Fetch all registrations with members with their corresponding (valid) registrations
      */
-    static async getRegistrationWithMembersForGroup(groupId: string, cycle: number): Promise<RegistrationWithMember[]> {
+    static async getRegistrationWithMembersForGroup(groupId: string): Promise<RegistrationWithMember[]> {
         let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()} from \`${Member.table}\`\n`;
         
-        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`
+        query += `JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`canRegister\` = 1)\n`
 
         // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
-        query += `where \`${Registration.table}\`.\`groupId\` = ? AND \`${Registration.table}\`.\`cycle\` = ?`
+        query += `where \`${Registration.table}\`.\`groupId\` = ?`
 
-        const [results] = await Database.select(query, [groupId, cycle])
+        const [results] = await Database.select(query, [groupId])
         const registrations: RegistrationWithMember[] = []
 
          // In the future we might add a 'reverse' method on manytoone relation, instead of defining the new relation. But then we need to store 2 model types in the many to one relation.
@@ -261,7 +261,7 @@ export class Member extends Model {
             return []
         }
         let query = `SELECT ${Member.getDefaultSelect()}, ${Registration.getDefaultSelect()}, ${User.getDefaultSelect()}  from \`${Member.table}\`\n`;
-        query += `LEFT JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`waitingList\` = 1)\n`
+        query += `LEFT JOIN \`${Registration.table}\` ON \`${Registration.table}\`.\`${Member.registrations.foreignKey}\` = \`${Member.table}\`.\`${Member.primary.name}\` AND (\`${Registration.table}\`.\`registeredAt\` is not null OR \`${Registration.table}\`.\`canRegister\` = 1)\n`
         query += Member.users.joinQuery(Member.table, User.table)+"\n"
 
         // We do an extra join because we also need to get the other registrations of each member (only one regitration has to match the query)
@@ -380,7 +380,11 @@ export class Member extends Model {
         return RegistrationWithMemberStruct.create({
             ...registration.getStructure(),
             cycle: registration.cycle,
-            member: MemberStruct.create(registration.member),
+            member: TinyMember.create({
+                id: registration.member.id,
+                firstName: registration.member.firstName,
+                lastName: registration.member.lastName,
+            }),
         })
     }
 
@@ -406,19 +410,22 @@ export class Member extends Model {
                 ).fetch()).flatMap(r => (r.members && (typeof r.members.id) === 'string') ? [r.members.id as string] : [])
             
             for (const id of memberIds) {
-                const member = await Member.getWithRegistrations(id)
-                await member?.updateMemberships()
+                await Member.updateMembershipsForId(id)
             }
         }).catch((e) => {
             console.error('Failed to update memberships for group id ', id), e
         });
     }
 
-    async updateMemberships(this: MemberWithRegistrations) {
-        console.log('Updating memberships for member: ' + this.id)
-        return await QueueHandler.schedule('updateMemberships-' + this.id, async () => {
+    static async updateMembershipsForId(id: string) {
+        return await QueueHandler.schedule('updateMemberships-' + id, async function (this: undefined) {
+            const me = await Member.getWithRegistrations(id)
+            if (!me) {
+                console.log('Skipping automatic membership for: ' + id, ' - member not found')
+                return
+            }
             const platform = await Platform.getShared()
-            const registrations = this.registrations.filter(r => r.group.periodId == platform.periodId && !r.waitingList && r.registeredAt && !r.deactivatedAt)
+            const registrations = me.registrations.filter(r => r.group.periodId == platform.periodId && r.registeredAt && !r.deactivatedAt)
 
             const defaultMemberships = registrations.flatMap(r => {
                 if (!r.group.defaultAgeGroupId) {
@@ -440,7 +447,7 @@ export class Member extends Model {
                 }]
             })
             // Get active memberships for this member that
-            const memberships = await MemberPlatformMembership.where({memberId: this.id, periodId: platform.periodId })
+            const memberships = await MemberPlatformMembership.where({memberId: me.id, periodId: platform.periodId })
             const now = new Date()
             const activeMemberships = memberships.filter(m => m.startDate <= now && m.endDate >= now && m.deletedAt === null)
             const activeMembershipsUndeletable = activeMemberships.filter(m => !m.canDelete() || !m.generated)
@@ -449,20 +456,20 @@ export class Member extends Model {
                 // Stop all active memberships taht were added automatically
                 for (const membership of activeMemberships) {
                     if (membership.canDelete() && membership.generated) {
-                        console.log('Removing membership because no longer registered member and not yet invoiced for: ' + this.id + ' - membership ' + membership.id)
+                        console.log('Removing membership because no longer registered member and not yet invoiced for: ' + me.id + ' - membership ' + membership.id)
                         membership.deletedAt = new Date()
                         await membership.save()
                     }
                 }
 
-                console.log('Skipping automatic membership for: ' + this.id, ' - no default memberships found')
+                console.log('Skipping automatic membership for: ' + me.id, ' - no default memberships found')
                 return
             }
 
 
             if (activeMembershipsUndeletable.length) {
                 // Skip automatic additions
-                console.log('Skipping automatic membership for: ' + this.id, ' - already has active memberships')
+                console.log('Skipping automatic membership for: ' + me.id, ' - already has active memberships')
                 return
             }
 
@@ -480,7 +487,7 @@ export class Member extends Model {
 
             // Check if already have the same membership
             if (activeMemberships.find(m => m.membershipTypeId == cheapestMembership.membership.id)) {
-                console.log('Skipping automatic membership for: ' + this.id, ' - already has this membership')
+                console.log('Skipping automatic membership for: ' + me.id, ' - already has this membership')
                 return
             }
 
@@ -490,9 +497,9 @@ export class Member extends Model {
             }
 
             // Can we revive an earlier deleted membership?
-            console.log('Creating automatic membership for: ' + this.id + ' - membership type ' + cheapestMembership.membership.id)
+            console.log('Creating automatic membership for: ' + me.id + ' - membership type ' + cheapestMembership.membership.id)
             const membership = new MemberPlatformMembership();
-            membership.memberId = this.id
+            membership.memberId = me.id
             membership.membershipTypeId = cheapestMembership.membership.id
             membership.organizationId = cheapestMembership.registration.organizationId
             membership.periodId = platform.periodId
@@ -508,11 +515,15 @@ export class Member extends Model {
             // This reasoning allows us to replace an existing membership with a cheaper one (not date based ones, but type based ones)
             for (const toDelete of activeMemberships) {
                 if (toDelete.canDelete() && toDelete.generated) {
-                    console.log('Removing membership because cheaper membership found for: ' + this.id + ' - membership ' + toDelete.id)
+                    console.log('Removing membership because cheaper membership found for: ' + me.id + ' - membership ' + toDelete.id)
                     toDelete.deletedAt = new Date()
                     await toDelete.save()
                 }
             }
         });
     }
+
+    async updateMemberships() {
+        return await Member.updateMembershipsForId(this.id)
+    }
 }

package/src/models/Payment.ts

@@ -110,39 +110,37 @@ export class Payment extends Model {
         }
 
         const {balanceItemPayments, balanceItems} = await Payment.loadBalanceItems(payments)
-        const {registrations, orders, members, groups} = await Payment.loadBalanceItemRelations(balanceItems);
+        const {registrations, orders, groups} = await Payment.loadBalanceItemRelations(balanceItems);
         
-        return this.getGeneralStructureFromRelations({
+        return await this.getGeneralStructureFromRelations({
             payments,
             registrations,
             orders,
-            members,
             balanceItemPayments,
             balanceItems,
             groups
         }, includeSettlements)
     }
 
-    static getGeneralStructureFromRelations({payments, registrations, orders, members, balanceItemPayments, balanceItems, groups}: {
+    static async getGeneralStructureFromRelations({payments, registrations, orders, balanceItemPayments, balanceItems, groups}: {
         payments: Payment[];
-        registrations: import("./Registration").Registration[];
+        registrations: import("./Member").RegistrationWithMember[];
         orders: import("./Order").Order[];
-        members: import("./Member").Member[];
         balanceItemPayments: import("./BalanceItemPayment").BalanceItemPayment[];
         balanceItems: import("./BalanceItem").BalanceItem[];
         groups: import("./Group").Group[];
-    }, includeSettlements = false): PaymentGeneral[] {
+    }, includeSettlements = false): Promise<PaymentGeneral[]> {
         if (payments.length === 0) {
             return []
         }
+        const {Member} = (await import("./Member"));
 
         return payments.map(payment => {
             return PaymentGeneral.create({
                 ...payment,
                 balanceItemPayments: balanceItemPayments.filter(item => item.paymentId === payment.id).map((item) => {
                     const balanceItem = balanceItems.find(b => b.id === item.balanceItemId)
-                    const registration = balanceItem?.registrationId && registrations.find(r => r.id === balanceItem.registrationId)
-                    const member = balanceItem?.memberId ? members.find(r => r.id === balanceItem.memberId) : undefined
+                    const registration = balanceItem?.registrationId ? registrations.find(r => r.id === balanceItem.registrationId) : null
                     const order = balanceItem?.orderId && orders.find(r => r.id === balanceItem.orderId)
                     const group = registration ? groups.find(g => g.id === registration.groupId) : null
 
@@ -154,8 +152,7 @@ export class Payment extends Model {
                         ...item,
                         balanceItem: BalanceItemDetailed.create({
                             ...balanceItem,
-                            registration: registration ? registration.setRelation(Registration.group, group!).getStructure() : null,
-                            member: member ? MemberStruct.create(member) : null,
+                            registration: registration ? Member.getRegistrationWithMemberStructure(registration.setRelation(Registration.group, group!)) : null,
                             order: order ? OrderStruct.create({...order, payment: null}) : null
                         })
                     })
@@ -195,22 +192,19 @@ export class Payment extends Model {
     }
 
     static async loadBalanceItemRelations(balanceItems: import("./BalanceItem").BalanceItem[]) {
-        const {Registration} = await import("./Registration");
         const {Order} = await import("./Order");
         const {Member} = await import("./Member");
 
         // Load members and orders
         const registrationIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.registrationId ? [b.registrationId] : []))
         const orderIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.orderId ? [b.orderId] : []))
-        const memberIds = Formatter.uniqueArray(balanceItems.flatMap(b => b.memberId ? [b.memberId] : []))
 
-        const registrations = await Registration.getByIDs(...registrationIds)
+        const registrations = await Member.getRegistrationWithMembersByIDs(registrationIds)
         const orders = await Order.getByIDs(...orderIds)
-        const members = await Member.getByIDs(...memberIds)
 
         const groupIds = Formatter.uniqueArray(registrations.map(r => r.groupId))
         const groups = await (await import("./Group")).Group.getByIDs(...groupIds)
 
-        return {registrations, orders, members, groups}
+        return {registrations, orders, groups}
     }
 }

package/src/models/Registration.ts

@@ -1,11 +1,13 @@
 import { column, Database, ManyToOneRelation, Model } from '@simonbackx/simple-database';
 import { Email } from '@stamhoofd/email';
-import { EmailTemplateType, PaymentMethod, PaymentMethodHelper, Recipient, Registration as RegistrationStructure, Replacement } from '@stamhoofd/structures';
+import { EmailTemplateType, PaymentMethod, PaymentMethodHelper, Recipient, Registration as RegistrationStructure, Replacement, StockReservation } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from "uuid";
 
 import { getEmailBuilder } from '../helpers/EmailBuilder';
-import { Document, EmailTemplate, Organization, User } from './';
+import { Document, EmailTemplate, Group, Organization, User } from './';
+import { ArrayDecoder } from '@simonbackx/simple-encoding';
+import { QueueHandler } from '@stamhoofd/queues';
 
 export class Registration extends Model {
     static table = "registrations"
@@ -69,6 +71,9 @@ export class Registration extends Model {
     @column({ type: "datetime", nullable: true })
     reservedUntil: Date | null = null
 
+    /**
+     * @deprecated - replaced by group type
+     */
     @column({ type: "boolean" })
     waitingList = false
 
@@ -88,6 +93,12 @@ export class Registration extends Model {
     @column({ type: "integer" })
     pricePaid = 0
 
+    /**
+     * Set to null if no reservations are made, to help faster querying
+     */
+    @column({ type: "json", decoder: new ArrayDecoder(StockReservation), nullable: true })
+    stockReservations: StockReservation[] = []
+
     static group: ManyToOneRelation<"group", import('./Group').Group>
 
     getStructure(this: Registration & {group: import('./Group').Group}) {
@@ -101,7 +112,7 @@ export class Registration extends Model {
     /**
      * Update the outstanding balance of multiple members in one go (or all members)
      */
-    static async updateOutstandingBalance(registrationIds: string[] | 'all', organizationId: string) {
+    static async updateOutstandingBalance(registrationIds: string[] | 'all', organizationId?: string) {
         if (registrationIds !== 'all' && registrationIds.length == 0) {
             return
         }
@@ -136,7 +147,7 @@ export class Registration extends Model {
         
         await Database.update(query, params)
 
-        if (registrationIds !== 'all') {
+        if (registrationIds !== 'all' && organizationId) {
             await Document.updateForRegistrations(registrationIds, organizationId)
         }
     }
@@ -149,7 +160,7 @@ export class Registration extends Model {
         const query = `
         SELECT COUNT(DISTINCT \`${Registration.table}\`.memberId) as c FROM \`${Registration.table}\` 
         JOIN \`groups\` ON \`groups\`.id = \`${Registration.table}\`.groupId
-        WHERE \`groups\`.organizationId = ? AND \`${Registration.table}\`.cycle = \`groups\`.cycle AND \`groups\`.deletedAt is null AND \`groups\`.status != 'Archived' AND \`${Registration.table}\`.registeredAt is not null AND \`${Registration.table}\`.waitingList = 0`
+        WHERE \`groups\`.organizationId = ? AND \`${Registration.table}\`.cycle = \`groups\`.cycle AND \`groups\`.deletedAt is null AND \`${Registration.table}\`.registeredAt is not null AND \`${Registration.table}\`.deactivatedAt is null`
         
         const [results] = await Database.select(query, [organizationId])
         const count = results[0]['']['c'];
@@ -162,26 +173,40 @@ export class Registration extends Model {
         }
     }
 
+    async deactivate() {
+        if (this.deactivatedAt !== null) {
+            return
+        }
+
+        // Clear the registration
+        this.deactivatedAt = new Date()
+        await this.save()
+        this.scheduleStockUpdate()
+        
+        const {Member} = await import('./Member');
+        await Member.updateMembershipsForId(this.memberId)
+    }
+
     async markValid(this: Registration) {
-        if (this.registeredAt !== null) {
+        if (this.registeredAt !== null && this.deactivatedAt === null) {
             await this.save();
             return false;
         }
 
-        if (this.waitingList && this.canRegister) {
-            this.waitingList = false
-        }
-        
         this.reservedUntil = null
-        this.registeredAt = new Date()
+        this.registeredAt =  this.registeredAt ?? new Date()
+        this.deactivatedAt = null
         this.canRegister = false
         await this.save();
+        this.scheduleStockUpdate()
+
+        const {Member} = await import('./Member');
+        await Member.updateMembershipsForId(this.memberId)
 
         await this.sendEmailTemplate({
             type: EmailTemplateType.RegistrationConfirmation
         });
 
-        const {Member} = await import('./Member');
         const member = await Member.getByID(this.memberId);
         if (member) {
             const registrationMemberRelation = new ManyToOneRelation(Member, "member")
@@ -408,4 +433,55 @@ export class Registration extends Model {
 
         Email.schedule(builder)
     }
+
+    shouldIncludeStock() {
+        return (this.registeredAt !== null && this.deactivatedAt === null) || this.canRegister || (this.reservedUntil && this.reservedUntil > new Date())
+    }
+
+
+
+    /**
+     * Adds or removes the order to the stock of the webshop (if it wasn't already included). If amounts were changed, only those
+     * changes will get added
+     * Should always happen in the webshop-stock queue to prevent multiple webshop writes at the same time
+     * + in combination with validation and reading the webshop
+     */
+    scheduleStockUpdate() {
+        const id = this.id;
+
+        QueueHandler.cancel('registration-stock-update-'+id);
+        QueueHandler.schedule('registration-stock-update-'+id, async function(this: undefined) {
+            const updated = await Registration.getByID(id);
+
+            if (!updated) {
+                return;
+            }
+            
+            // Start with clearing all the stock reservations we've already made
+            if (updated.stockReservations) {
+                const groupIds = Formatter.uniqueArray(updated.stockReservations.flatMap(r => r.objectType === 'Group' ? [r.objectId] : []));
+                for (const groupId of groupIds) {
+                    const stocks = StockReservation.filter('Group', groupId, updated.stockReservations);
+                    
+                    // Technically we don't need to await this, but okay...
+                    await Group.freeStockReservations(groupId, stocks);
+                }
+            }
+
+            if (updated.shouldIncludeStock()) {
+                const myStockReservations: StockReservation[] = [];
+
+                // todo: build
+
+                updated.stockReservations = myStockReservations;
+                await updated.save();
+            } else {
+                if (updated.stockReservations.length) {
+                    updated.stockReservations = [];
+                    await updated.save();
+                }
+            }
+
+        }).catch(console.error)
+    }
 }

package/src/models/StripeAccount.ts

@@ -68,4 +68,4 @@ export class StripeAccount extends Model {
             bank_account_bank_name: account.external_accounts?.data[0]?.bank_name ?? this.meta.bank_account_bank_name ?? "",
         });
     }
-}
+}

package/src/models/StripeCheckoutSession.ts

@@ -19,4 +19,10 @@ export class StripeCheckoutSession extends Model {
 
     @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
 }

package/src/models/StripePaymentIntent.ts

@@ -19,4 +19,10 @@ export class StripePaymentIntent extends Model {
 
     @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
 }