Problem with include model M:N in multitenant app - node.js

Question

I have a nodejs app using sequelize and postgres as a database, the architecture of the app is multitenant with separate schemas in the same database, the problem I present is that when including the permissions model in the user query, sequelize It doesn't take me the schema for the join table and therefore tries to query it in the default schema (public). these are my models:
Users:
export const USERS_TABLE = 'users';
#Table({
timestamps: false,
tableName: USERS_TABLE,
})
export class User extends Model {
#AfterCreate
static deletePassword(instance: User) {
instance.password = null;
}
#Column({
autoIncrement: false,
primaryKey: true,
type: DataType.STRING(36),
defaultValue: UUIDV4(),
field: 'user_id',
allowNull: false,
})
userId: string;
#Column({
type: DataType.STRING(20),
})
provider: string;
#Column({
type: DataType.STRING(50),
allowNull: false,
unique: true,
})
email: string;
#Column({
type: DataType.STRING(100),
field: 'customer_id',
unique: true,
})
customerId: string;
#Column({
type: DataType.STRING(50),
allowNull: false,
unique: true,
})
username: string;
#Column({
type: DataType.STRING(10),
unique: true,
})
phone: string;
#Column({
type: DataType.STRING(255),
field: 'recovery_token',
unique: true,
})
recoveryToken: string;
#Column({
type: DataType.STRING(10),
field: 'verify_code',
})
verifyCode: string;
#Column({
type: DataType.STRING(100),
})
password: string;
#Column({
type: DataType.TEXT,
})
devices: string;
#Column({
type: DataType.BOOLEAN,
defaultValue: false,
})
deleted: boolean;
#Column({
type: DataType.BOOLEAN,
defaultValue: false,
})
verified: boolean;
#Column({
type: DataType.INTEGER,
defaultValue: 1,
})
status: number;
#ForeignKey(() => Role)
#Column({
type: DataType.STRING(36),
field: 'role_id',
allowNull: false,
references: {
model: ROLES_TABLE,
key: 'id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
roleId: string;
#ForeignKey(() => Profile)
#Column({
type: DataType.STRING,
field: 'profile_id',
allowNull: false,
references: {
model: PROFILES_TABLE,
key: 'id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
profileId: string;
#ForeignKey(() => Subscription)
#Column({
type: DataType.STRING,
field: 'subscription_id',
references: {
model: SUBSCRIPTION_TABLE,
key: 'subscription_id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
subscriptionId: string;
#Column({
allowNull: false,
type: DataType.DATE,
field: 'created_at',
defaultValue: new Date(),
})
createdAt: Date;
#Column({
allowNull: false,
type: DataType.DATE,
field: 'updated_at',
defaultValue: new Date(),
})
updatedAt: Date;
// Prueba tenantId
#Column({
type: DataType.STRING(36),
field: 'tenant_id',
references: {
model: TENANT_TABLE,
key: 'id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
tenantId?: string;
#ForeignKey(() => Seat)
#Column({
type: DataType.STRING(36),
field: 'seat_id',
references: {
model: SEAT_TABLE,
key: 'seat_id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
seatId: string;
// associations
#BelongsToMany(() => Permission, () => UserPermission)
Permissions: Permission[];
#BelongsTo(() => Subscription) Subscription: Subscription;
#BelongsTo(() => Profile) Profile: Profile;
#BelongsTo(() => Role) Role: Role;
#BelongsTo(() => Seat) Seat: Seat;
}
Permissions
export const PERMISSIONS_TABLE = 'permissions';
#Table({
timestamps: false,
tableName: PERMISSIONS_TABLE,
})
export class Permission extends Model {
#Column({
allowNull: false,
field: 'permission_id',
autoIncrement: false,
primaryKey: true,
type: DataType.STRING(36),
defaultValue: UUIDV4(),
})
permissionId: string;
#Column({
type: DataType.STRING(20),
allowNull: false,
})
name: string;
#Column({
type: DataType.STRING(150),
})
description: string;
#Column({
type: DataType.TEXT,
allowNull: false,
})
models: string;
#ForeignKey(() => Subscription)
#Column({
type: DataType.STRING,
allowNull: false,
field: 'subscription_id',
references: {
model: SUBSCRIPTION_TABLE,
key: 'subscription_id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
subscriptionId: string;
#Column({
type: DataType.BOOLEAN,
allowNull: false,
defaultValue: true,
})
status: boolean;
#Column({
type: DataType.STRING(36),
field: 'tenant_id',
references: {
model: TENANT_TABLE,
key: 'id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
tenantId?: string;
#Column({
allowNull: false,
type: DataType.DATE,
field: 'created_at',
defaultValue: new Date(),
})
createdAt: Date;
#Column({
allowNull: false,
type: DataType.DATE,
field: 'updated_at',
defaultValue: new Date(),
})
updatedAt: Date;
// Associations
#BelongsToMany(() => User, () => UserPermission) Users: User[];
}
Join Table
export const USERS_PERMISSIONS_TABLE = 'user_permissions';
#Table({
timestamps: false,
tableName: USERS_PERMISSIONS_TABLE,
})
export class UserPermission extends Model {
#ForeignKey(() => User)
#Column({
type: DataType.STRING,
field: 'user_id',
allowNull: false,
references: {
model: USERS_TABLE,
key: 'user_id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
userId: string;
#ForeignKey(() => Permission)
#Column({
type: DataType.STRING,
field: 'permission_id',
allowNull: false,
references: {
model: PERMISSIONS_TABLE,
key: 'permission_id',
},
onUpdate: 'CASCADE',
onDelete: 'SET NULL',
})
permissionId: string;
}
I pass the necessary parameters to a base class that performs my query
users = await super.getAll(
tenantId,
[
Role.schema(schemaName),
Profile.schema(schemaName),
Subscription,
Permission.schema(schemaName),
],
body.page,
body.size,
{},
);
findAll method of Super Class
public async getAll(
tenantId: string,
includeModel?: object,
page?: string,
size?: string,
where?: Record<string, unknown>,
) {
try {
// free_id
let records: unknown;
const free = tenantId.split('_');
const tenantName: string = getTenantName(tenantId);
if (free[0] === 'free') {
where.tenantId = free[1];
}
if (!includeModel) {
const { limit, offset } = paginate(page, size);
records = await this.model.schema(tenantName).findAndCountAll({
where,
limit,
offset,
});
return new HttpResponse.getSuccessful(records);
}
const { limit, offset } = paginate(page, size);
records = await this.model.schema(tenantName).findAndCountAll({
where,
limit,
offset,
include: includeModel,
});
return new HttpResponse.getSuccessful(records);
} catch (e) {
throw boom.badRequest(e);
}
}
The generated query And The error:
sql: `SELECT count("User"."user_id") AS "count" FROM "free_trial"."users" AS "User" LEFT OUTER JOIN "free_trial"."roles" AS "Role" ON "User"."role_id" = "Role"."role_id" LEFT OUTER JOIN "free_trial"."profiles" AS "Profile" ON "User"."profile_id" = "Profile"."profile_id" LEFT OUTER JOIN "subscriptions" AS "Subscription" ON "User"."subscription_id" = "Subscription"."subscription_id" LEFT OUTER JOIN ( "user_permissions" AS "Permissions->UserPermission" INNER JOIN "free_trial"."permissions" AS "Permissions" ON "Permissions"."permission_id" = "Permissions->UserPermission"."permission_id") ON "User"."user_id" = "Permissions->UserPermission"."user_id" WHERE "User"."tenant_id" = '72a5afbe-dc66-4b54-a428-d7bed9a2cbd9';`,
parameters: {},
isBoom: true,
isServer: false,
data: null,
output: {
statusCode: 400,
payload: {
statusCode: 400,
error: 'Bad Request',
message: 'no existe la relación «user_permissions»'
},
headers: {}
}
}
As can be seen in the query, all the tables are preceded by the name of the schema in which they are found, but in the join table it refers to the public schema and therefore it cannot be found; I have already tried thousands of ways but nothing seems to work, any ideas are appreciated.
I have tried to pass the name of the schema to the join table, referring to it in the include but it does not give results, I also tried within permissions to include the join table to be able to pass the name of the schema.