@stamhoofd/models 2.120.6 → 2.122.0

package/src/models/PasswordToken.ts

@@ -1,13 +1,15 @@
 import type { ManyToOneRelation } from '@simonbackx/simple-database';
 import { column, Database } from '@simonbackx/simple-database';
-import type {I18n} from '@stamhoofd/backend-i18n';
+import type { I18n } from '@stamhoofd/backend-i18n';
 import { QueryableModel } from '@stamhoofd/sql';
 import basex from 'base-x';
 import crypto from 'crypto';
 
-import type {Organization} from './Organization.js';
+import type { Organization } from './Organization.js';
 import { User } from './User.js';
 import { SimpleError } from '@simonbackx/simple-errors';
+import { getAppHost } from '@stamhoofd/structures';
+import { Platform } from './Platform.js';
 const ALPHABET = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz';
 const bs58 = basex(ALPHABET);
 
@@ -110,8 +112,7 @@ export class PasswordToken extends QueryableModel {
 
         if (validUntil) {
             token.validUntil = new Date(validUntil);
-        }
-        else {
+        } else {
             token.validUntil = new Date();
             token.validUntil.setTime(token.validUntil.getTime() + 3 * 3600 * 1000);
         }
@@ -122,29 +123,28 @@ export class PasswordToken extends QueryableModel {
     }
 
     static async getPasswordRecoveryUrl(user: User, organization: Organization | null, i18n: I18n, validUntil?: Date) {
-        if (user.organizationId !== null && ((user.organizationId ?? null) !== (organization?.id ?? null))) {
-            throw new Error('Unexpected mismatch in organization id for PasswordToken');
-        }
         // Send an e-mail to say you already have an account + follow password forgot flow
         const token = await PasswordToken.createToken(user, validUntil);
+        return token.getPasswordRecoveryUrl(organization, i18n, user);
+    }
 
-        let host: string;
-        if (user.permissions || !organization || STAMHOOFD.userMode === 'platform') {
-            host = 'https://' + (STAMHOOFD.domains.dashboard) + '/' + i18n.locale;
-            if (user.organizationId && organization) {
-                host += '/auto/' + encodeURIComponent(organization.uri);
-            }
-            return host + '/reset-password?token=' + encodeURIComponent(token.token);
+    /**
+     * Build the password recovery url for this (already created) token.
+     * Pass the user to avoid an extra query when it is already loaded.
+     */
+    async getPasswordRecoveryUrl(organization: Organization | null, i18n: I18n, user?: User) {
+        const tokenUser = user ?? await User.getByID(this.userId);
+        if (!tokenUser) {
+            throw new Error('PasswordToken without a valid user');
         }
 
-        host = 'https://' + organization.getHost(i18n);
-        return host + '/reset-password?token=' + encodeURIComponent(token.token);
-    }
+        if (tokenUser.organizationId !== null && ((tokenUser.organizationId ?? null) !== (organization?.id ?? null))) {
+            throw new Error('Unexpected mismatch in organization id for PasswordToken');
+        }
 
-    static async getMagicSignInUrl(user: User, organization: Organization) {
-        // For now we don't add a token yet for security. We might add some sort of email validation thing later on
-        const host = 'https://' + organization.getHost();
-        return Promise.resolve(host + '/login' + '?email=' + encodeURIComponent(user.email) + '&hasAccount=' + (user.hasAccount() ? 1 : 0));
+        const hasOrganizationPermissions = organization ? tokenUser.permissions?.forOrganization(organization, await Platform.getSharedStruct())?.isEmpty === false : false;
+        const host = 'https://' + getAppHost(hasOrganizationPermissions ? 'dashboard' : 'registration', organization, hasOrganizationPermissions, i18n);
+        return host + '/reset-password?token=' + encodeURIComponent(this.token);
     }
 
     static async clearFor(userId: string) {

package/src/models/Payment.ts

@@ -1,10 +1,10 @@
 import { column } from '@simonbackx/simple-database';
-import type { PaymentMethod, PaymentStatus} from '@stamhoofd/structures';
-import { BalanceItemDetailed, BalanceItemPaymentDetailed, BaseOrganization, PaymentCustomer, PaymentGeneral, PaymentProvider, PaymentType, Settlement, TransferSettings } from '@stamhoofd/structures';
+import { BalanceItemDetailed, BalanceItemPaymentDetailed, BaseOrganization, PaymentCustomer, PaymentGeneral, PaymentMethod, PaymentProvider, PaymentStatus, PaymentType, Settlement, TransferSettings } from '@stamhoofd/structures';
 import { Formatter } from '@stamhoofd/utility';
 import { v4 as uuidv4 } from 'uuid';
 
-import { QueryableModel } from '@stamhoofd/sql';
+import { QueryableModel, SQL } from '@stamhoofd/sql';
+import { CreateMandateSettings } from '@stamhoofd/structures/checkout/CreateMandateSettings.js';
 import type { BalanceItem } from './BalanceItem.js';
 import type { BalanceItemPayment } from './BalanceItemPayment.js';
 import { Organization } from './Organization.js';
@@ -52,6 +52,19 @@ export class Payment extends QueryableModel {
     @column({ type: 'string', nullable: true })
     payingUserId: string | null = null;
 
+    /**
+     * External ID of the mandate used for this payment
+     */
+    @column({ type: 'string', nullable: true })
+    mandateId: string | null = null;
+
+    /**
+     * Link to related payment that was reversed.
+     * Used for refunds and chargebacks
+     */
+    @column({ type: 'string', nullable: true })
+    reversingPaymentId: string | null = null;
+
     /**
      * @deprecated
      */
@@ -75,19 +88,30 @@ export class Payment extends QueryableModel {
     @column({ type: 'string', nullable: true })
     stripeAccountId: string | null = null;
 
+    @column({ type: 'json', decoder: CreateMandateSettings, nullable: true })
+    createMandate: CreateMandateSettings | null = null;
+
     /**
      * Total price
      */
     @column({ type: 'integer' })
     price: number;
 
+    /**
+     * Total price refunded or charged back
+     */
+    @column({ type: 'integer' })
+    refundedAmount = 0;
+
     /**
      * The difference between the sum of the balance item payments price and the price of the payment, caused by rounding to 1 cent.
      * This cannot be >= 100 (= 0,01 euro) or <= -100 (=-0,01 euro)
      *
+     * For understanding the sign of the value, regard it as an extra balance item to the payment.
+     *
      * Just like all prices, this price is stored per ten thousand (1 = 0,0001 ). Storing smaller units is not possible because even in balance items, the price to pay cannot be smaller than 0,0001 euro
      *
-     * E.g. total price to pay is 0,242 because of VAT, then we round this to 0,24. The roundingAmount will be -0,002 in this case.
+     * E.g. total price to pay is 0,242 because of VAT, then we round this to 0,24. The roundingAmount will be -0,002 in this case, because all the items (0,242) - 0,002 = 0,24.
      */
     @column({ type: 'integer' })
     roundingAmount = 0;
@@ -122,6 +146,20 @@ export class Payment extends QueryableModel {
     @column({ type: 'integer' })
     serviceFeeManualCharged = 0;
 
+    /**
+     * Transfer fee - if we need to charge this for a certain provider
+     *
+     * This EXCLUDES VAT
+     */
+    @column({ type: 'integer' })
+    transferFeeManual = 0;
+
+    /**
+     * Part of the transferFeeManual, that has been invoiced (added to outstanding balance)
+     */
+    @column({ type: 'integer' })
+    transferFeeManualCharged = 0;
+
     /**
      * Included in the total price
      */
@@ -137,6 +175,12 @@ export class Payment extends QueryableModel {
     @column({ type: 'string', nullable: true })
     invoiceId: string | null = null;
 
+    /**
+     * In case the payment was initiated by an admin or not.
+     */
+    @column({ type: 'string', nullable: true })
+    adminUserId: string | null = null;
+
     @column({
         type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
@@ -177,11 +221,24 @@ export class Payment extends QueryableModel {
     @column({ type: 'string', nullable: true })
     ibanName: string | null = null;
 
+    get canChangeStatus() {
+        return this.price !== 0 && (this.method === PaymentMethod.Transfer || this.method === PaymentMethod.PointOfSale || this.method === PaymentMethod.Unknown);
+    }
+
     generateDescription(organization: Organization, reference: string, replacements: { [key: string]: string } = {}) {
         const settings = this.transferSettings ?? organization.meta.transferSettings;
         this.transferDescription = settings.generateDescription(reference, organization.address.country, replacements);
     }
 
+    async updateRefundedAmount() {
+        this.refundedAmount = await Payment.select()
+            .where('organizationId', this.organizationId)
+            .where('reversingPaymentId', this.id)
+            .where('status', PaymentStatus.Succeeded)
+            .sum(SQL.column('price'));
+        await this.save();
+    }
+
     static roundPrice(price: number) {
         return Math.round(price / 100) * 100;
     }

package/src/models/Registration.ts

@@ -1,12 +1,12 @@
 import type { ManyToOneRelation } from '@simonbackx/simple-database';
 import { column } from '@simonbackx/simple-database';
-import type { RecordAnswer} from '@stamhoofd/structures';
-import { AppliedRegistrationDiscount, GroupPrice, RecordAnswerDecoder, RegisterItemOption, Registration as RegistrationStructure, StockReservation } from '@stamhoofd/structures';
+import type { RecordAnswer } from '@stamhoofd/structures';
+import { AppliedRegistrationDiscount, GroupPrice, RecordAnswerMapDecoder, RegisterItemOption, Registration as RegistrationStructure, StockReservation } from '@stamhoofd/structures';
 import { v4 as uuidv4 } from 'uuid';
 
 import { ArrayDecoder, MapDecoder, StringDecoder } from '@simonbackx/simple-encoding';
 import { QueryableModel } from '@stamhoofd/sql';
-import type {Group} from './Group.js';
+import type { Group } from './Group.js';
 
 export class Registration extends QueryableModel {
     static table = 'registrations';
@@ -39,7 +39,7 @@ export class Registration extends QueryableModel {
     @column({ type: 'json', decoder: new ArrayDecoder(RegisterItemOption) })
     options: RegisterItemOption[] = [];
 
-    @column({ type: 'json', decoder: new MapDecoder(StringDecoder, RecordAnswerDecoder) })
+    @column({ type: 'json', decoder: RecordAnswerMapDecoder })
     recordAnswers: Map<string, RecordAnswer> = new Map();
 
     /**
@@ -117,6 +117,7 @@ export class Registration extends QueryableModel {
     waitingList = false;
 
     /**
+     * @deprecated - use RegistrationInvitation instead
      * When a registration is on the waiting list or is invite only, set this to true to allow the user to
      * register normally.
      */
@@ -165,6 +166,6 @@ export class Registration extends QueryableModel {
     }
 
     shouldIncludeStock() {
-        return (this.registeredAt !== null && this.deactivatedAt === null) || this.canRegister || (this.reservedUntil && this.reservedUntil > new Date());
+        return (this.registeredAt !== null && this.deactivatedAt === null) || (this.reservedUntil && this.reservedUntil > new Date());
     }
 }

package/src/models/RegistrationInvitation.ts

@@ -0,0 +1,40 @@
+import { column } from '@simonbackx/simple-database';
+import { v4 as uuidv4 } from 'uuid';
+
+import { QueryableModel } from '@stamhoofd/sql';
+
+/**
+ * Invitation to register for a group. If an invitation exists the member can always register even if he does not meet the requirements of the group.
+ * Used for allowing members who are on a waiting list to register for a group.
+ */
+export class RegistrationInvitation extends QueryableModel {
+    static table = 'registration_invitations';
+
+    @column({
+        primary: true, type: 'string', beforeSave(value) {
+            return value ?? uuidv4();
+        },
+    })
+    id: string;
+
+    @column({ type: 'string' })
+    groupId: string;
+
+    @column({ type: 'string' })
+    memberId: string;
+
+    @column({ type: 'string' })
+    organizationId: string;
+
+    @column({
+        type: 'datetime', beforeSave(old?: any) {
+            if (old !== undefined) {
+                return old;
+            }
+            const date = new Date();
+            date.setMilliseconds(0);
+            return date;
+        },
+    })
+    createdAt: Date;
+}

package/src/models/STCredit.ts

@@ -49,4 +49,36 @@ export class STCredit extends QueryableModel {
         skipUpdate: true,
     })
     updatedAt: Date;
+
+    static async getForOrganization(organizationId: string) {
+        return await STCredit.where({ organizationId }, {
+            sort: [{
+                column: 'createdAt',
+                direction: 'DESC',
+            }],
+        });
+    }
+
+    static async getBalance(organizationId: string) {
+        const now = new Date();
+        const credits = await this.getForOrganization(organizationId);
+        credits.reverse();
+        let balance = 0;
+
+        for (const credit of credits) {
+            if (credit.expireAt !== null && credit.expireAt <= now) {
+                continue;
+            }
+            // TODO: we can expire credits here
+            balance += credit.change;
+            if (balance < 0) {
+                // This is needed to make deleting credit and expiring credit work.
+                // At no point in time, the credits can get negative.
+                // E.g. Getting credits, using them, and later expiring 'getting the credits' won't have impact on future credits
+                balance = 0;
+            }
+        }
+
+        return { balance: balance };
+    }
 }

package/src/models/STInvoice.ts

@@ -20,12 +20,14 @@ export class STInvoice extends QueryableModel {
     id!: string;
 
     /**
+     * @deprecated
      * Organization that made the invoice. Can be null if the organization was deleted and for the migration from V1 -> V2
      */
     @column({ type: 'string', nullable: true })
-    organizationId: string | null;
+    protected organizationId: string | null;
 
     /**
+     *
      * Organization that is associated with this invoice (can be null if deleted or unknown)
      */
     @column({ type: 'string', nullable: true })
@@ -56,6 +58,12 @@ export class STInvoice extends QueryableModel {
     @column({ type: 'datetime', nullable: true })
     paidAt: Date | null = null;
 
+    /**
+     * If a invoice was refunded because of a cancellation, we store the negative invoice id here
+     */
+    @column({ type: 'string', nullable: true })
+    negativeInvoiceId: string | null = null;
+
     @column({
         type: 'datetime', beforeSave(old?: any) {
             if (old !== undefined) {
@@ -117,14 +125,12 @@ export class STInvoice extends QueryableModel {
                                 cardLabel: ('cardLabel' in details ? details.cardLabel : null),
                             }),
                         }));
-                    }
-                    catch (e) {
+                    } catch (e) {
                         console.error(e);
                     }
                 }
             }
-        }
-        catch (e) {
+        } catch (e) {
             console.error(e);
         }
         return mandates;

package/src/models/STPackage.ts

@@ -65,6 +65,19 @@ export class STPackage extends QueryableModel {
     @column({ type: 'datetime', nullable: true })
     lastEmailAt: Date | null = null;
 
+    /**
+     * Helper to handle edge cases where validUntil is null but removeAt is set
+     */
+    get endDate() {
+        if (!this.removeAt) {
+            return this.validUntil;
+        }
+        if (!this.validUntil) {
+            return this.removeAt;
+        }
+        return new Date(Math.min(this.validUntil.getTime(), this.removeAt.getTime()));
+    }
+
     async activate() {
         if (this.validAt !== null) {
             return;
@@ -150,8 +163,7 @@ export class STPackage extends QueryableModel {
             pack.meta.pricingType = STPricingType.Fixed;
             pack.validUntil = null;
             pack.removeAt = null;
-        }
-        else if (pack.meta.type === STPackageType.Members) {
+        } else if (pack.meta.type === STPackageType.Members) {
             pack.meta.serviceFeeFixed = 0;
             pack.meta.serviceFeePercentage = 0;
             pack.meta.serviceFeeMinimum = 0;
@@ -165,8 +177,6 @@ export class STPackage extends QueryableModel {
     }
 
     createStatus(): STPackageStatus {
-        // TODO: if payment failed: temporary set valid until to 2 weeks after last/first failed payment
-
         return STPackageStatus.create({
             startDate: this.meta.startDate,
             validUntil: this.validUntil,
@@ -205,20 +215,16 @@ export class STPackage extends QueryableModel {
         if (this.meta.type === STPackageType.Members) {
             type = EmailTemplateType.MembersExpirationReminder;
             allowDays = 32;
-        }
-        else if (this.meta.type === STPackageType.Webshops) {
+        } else if (this.meta.type === STPackageType.Webshops) {
             type = EmailTemplateType.WebshopsExpirationReminder;
             allowDays = 32;
-        }
-        else if (this.meta.type === STPackageType.SingleWebshop) {
+        } else if (this.meta.type === STPackageType.SingleWebshop) {
             type = EmailTemplateType.SingleWebshopExpirationReminder;
             allowDays = 7;
-        }
-        else if (this.meta.type === STPackageType.TrialMembers) {
+        } else if (this.meta.type === STPackageType.TrialMembers) {
             type = EmailTemplateType.TrialMembersExpirationReminder;
             allowDays = 3;
-        }
-        else if (this.meta.type === STPackageType.TrialWebshops) {
+        } else if (this.meta.type === STPackageType.TrialWebshops) {
             type = EmailTemplateType.TrialWebshopsExpirationReminder;
             allowDays = 3;
         }
@@ -237,8 +243,7 @@ export class STPackage extends QueryableModel {
                 });
             }
             this.lastEmailAt = new Date();
-        }
-        else {
+        } else {
             console.log('Skip sending expiration email for ' + this.id + ' (no type)');
         }
 

package/src/models/UsedRegisterCode.ts

@@ -25,6 +25,13 @@ export class UsedRegisterCode extends QueryableModel {
      * Set if this has been rewarded
      */
     @column({ type: 'string', nullable: true })
+    balanceItemId: string | null = null;
+
+    /**
+     * @deprecated Migrated to balanceItemId
+     * Set if this has been rewarded
+     */
+    @column({ type: 'string', nullable: true })
     creditId: string | null = null;
 
     @column({
@@ -48,4 +55,31 @@ export class UsedRegisterCode extends QueryableModel {
         skipUpdate: true,
     })
     updatedAt: Date;
+
+    static async getFor(organizationId: string): Promise<UsedRegisterCode | undefined> {
+        const code = await this.where({ organizationId }, { limit: 1 });
+        return code[0] ?? undefined;
+    }
+
+    static async getAll(code: string) {
+        const used = await UsedRegisterCode.where({
+            code,
+        });
+        return used;
+    }
+
+    static async getUsed(code: string) {
+        const used = await UsedRegisterCode.select()
+            .where('code', code)
+            .andWhere('balanceItemId', '!=', null)
+            .fetch();
+        return used;
+    }
+
+    static async getUsedCount(code: string) {
+        return await UsedRegisterCode.select()
+            .where('code', code)
+            .andWhere('balanceItemId', '!=', null)
+            .count();
+    }
 }

package/src/models/User.ts

@@ -141,20 +141,19 @@ export class User extends QueryableModel {
         return global;
     }
 
-    static async getAdmins(organizationId: string, options?: { verified?: boolean }) {
+    static async getAdmins(organizationId: string | string[], options?: { verified?: boolean }) {
         if (STAMHOOFD.userMode === 'platform') {
             // Custom implementation
             const q = User.select()
                 .where('organizationId', null)
                 .where('permissions', '!=', null)
                 .where(
-                    SQL.jsonExtract(
-                        SQL.jsonExtract(SQL.column('permissions'), '$.value.organizationPermissions'),
-                        '$."' + organizationId + '"',
-                        true,
+                    SQL.jsonOverlaps(
+                        SQL.jsonKeys(SQL.jsonExtract(SQL.column('permissions'), '$.value.organizationPermissions')),
+                        SQL.cast(SQL.scalar(JSON.stringify(Array.isArray(organizationId) ? organizationId : [organizationId])), 'JSON'),
                     ),
-                    '!=',
-                    null,
+                    '=',
+                    1,
                 )
             ;
 

package/src/models/_relations.ts

@@ -22,6 +22,10 @@ import { Group } from './Group.js';
 import { Registration } from './Registration.js';
 import { Token } from './Token.js';
 import { PasswordToken } from './PasswordToken.js';
+import { City } from './addresses/City.js';
+import { Province } from './addresses/Province.js';
+import { PostalCode } from './addresses/PostalCode.js';
+import { Street } from './addresses/Street.js';
 
 if (User === undefined) {
     throw new Error('Unexpected missing User');
@@ -131,3 +135,28 @@ if (!PasswordToken.relations) {
 PasswordToken.user = new ManyToOneRelation(User, 'user');
 PasswordToken.user.foreignKey = 'userId';
 PasswordToken.relations.push(PasswordToken.user);
+
+if (!City.relations) {
+    City.relations = [];
+}
+City.parentCity = new ManyToOneRelation(City, 'parentCity');
+City.parentCity.foreignKey = 'parentCityId';
+City.relations.push(City.parentCity);
+
+City.province = new ManyToOneRelation(Province, 'province');
+City.province.foreignKey = 'provinceId';
+City.relations.push(City.province);
+
+if (!PostalCode.relations) {
+    PostalCode.relations = [];
+}
+PostalCode.city = new ManyToOneRelation(City, 'city');
+PostalCode.city.foreignKey = 'cityId';
+PostalCode.relations.push(PostalCode.city);
+
+if (!Street.relations) {
+    Street.relations = [];
+}
+Street.city = new ManyToOneRelation(City, 'city');
+Street.city.foreignKey = 'cityId';
+Street.relations.push(Street.city);

package/src/models/addresses/City.ts

@@ -1,9 +1,10 @@
-import { column, ManyToOneRelation } from '@simonbackx/simple-database';
+import { column } from '@simonbackx/simple-database';
+import type { ManyToOneRelation } from '@simonbackx/simple-database';
 import type { Country } from '@stamhoofd/types/Country';
 import { v4 as uuidv4 } from 'uuid';
 
 import { QueryableModel } from '@stamhoofd/sql';
-import { Province } from './Province.js';
+import type { Province } from './Province.js';
 
 export class City extends QueryableModel {
     static table = 'cities';
@@ -18,15 +19,16 @@ export class City extends QueryableModel {
     @column({ type: 'string' })
     name: string;
 
-    @column({ type: 'string', foreignKey: City.province })
+    @column({ type: 'string' })
     provinceId: string;
 
-    @column({ type: 'string', foreignKey: City.parentCity, nullable: true })
+    @column({ type: 'string', nullable: true })
     parentCityId: string | null = null;
 
     @column({ type: 'string' })
     country: Country;
 
-    static parentCity = new ManyToOneRelation(City, 'parentCity');
-    static province = new ManyToOneRelation(Province, 'province');
+    // Relations are wired up in _relations.ts (after the classes are defined) to avoid circular references.
+    static parentCity: ManyToOneRelation<'parentCity', City>;
+    static province: ManyToOneRelation<'province', Province>;
 }

package/src/models/addresses/PostalCode.test.ts

@@ -3,6 +3,7 @@ import { Country } from '@stamhoofd/types/Country';
 import { City } from './City.js';
 import { PostalCode } from './PostalCode.js';
 import { Province } from './Province.js';
+import '../_relations.js';
 
 describe('Model.PostalCode', () => {
     let oostVlaanderen!: Province;

package/src/models/addresses/PostalCode.ts

@@ -1,4 +1,5 @@
-import { column, Database, ManyToOneRelation } from '@simonbackx/simple-database';
+import { column, Database } from '@simonbackx/simple-database';
+import type { ManyToOneRelation } from '@simonbackx/simple-database';
 import { SimpleError } from '@simonbackx/simple-errors';
 import { QueryableModel } from '@stamhoofd/sql';
 import { Country } from '@stamhoofd/types/Country';
@@ -20,13 +21,14 @@ export class PostalCode extends QueryableModel {
     @column({ type: 'string' })
     postalCode: string;
 
-    @column({ type: 'string', foreignKey: PostalCode.city })
+    @column({ type: 'string' })
     cityId: string;
 
     @column({ type: 'string' })
     country: Country;
 
-    static city = new ManyToOneRelation(City, 'city');
+    // Relation is wired up in _relations.ts (after the classes are defined) to avoid circular references.
+    static city: ManyToOneRelation<'city', City>;
 
     /**
      * Search for a given city via it's postal code and country, collecting information about the city (id), parentCity (id) and province (id)

package/src/models/addresses/Street.ts

@@ -1,8 +1,9 @@
-import { column, ManyToOneRelation } from '@simonbackx/simple-database';
+import { column } from '@simonbackx/simple-database';
+import type { ManyToOneRelation } from '@simonbackx/simple-database';
 import { QueryableModel } from '@stamhoofd/sql';
 import { v4 as uuidv4 } from 'uuid';
 
-import { City } from './City.js';
+import type { City } from './City.js';
 
 export class Street extends QueryableModel {
     static table = 'streets';
@@ -17,8 +18,9 @@ export class Street extends QueryableModel {
     @column({ type: 'string' })
     name: string;
 
-    @column({ type: 'string', foreignKey: Street.city })
+    @column({ type: 'string' })
     cityId: string;
 
-    static city = new ManyToOneRelation(City, 'city');
+    // Relation is wired up in _relations.ts (after the classes are defined) to avoid circular references.
+    static city: ManyToOneRelation<'city', City>;
 }

package/src/models/index.ts

@@ -61,5 +61,8 @@ export * from './UitpasClientCredential.js';
 
 export * from './Invoice.js';
 export * from './InvoicedBalanceItem.js';
+export * from './RegistrationInvitation.js';
+
+export * from './v1GroupMigrationData.js';
 
 import './_relations.js';