@bunnykit/orm 0.1.5 → 0.1.7

package/dist/bin/bunny.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env bun
 import { Connection } from "../src/connection/Connection.js";
+import { ConnectionManager } from "../src/connection/ConnectionManager.js";
+import { TenantContext } from "../src/connection/TenantContext.js";
+import { configureBunny } from "../src/config/BunnyConfig.js";
 import { Migrator } from "../src/migration/Migrator.js";
 import { MigrationCreator } from "../src/migration/MigrationCreator.js";
 import { TypeGenerator } from "../src/typegen/TypeGenerator.js";
@@ -18,6 +21,126 @@ function parseEnvPathSetting(value) {
         return undefined;
     return paths.length === 1 ? paths[0] : paths;
 }
+function getDefaultMigrationsPath(config) {
+    return config.migrationsPath || config.migrations?.landlord || "./database/migrations";
+}
+function getFirstMigrationPath(path) {
+    return normalizePathList(path).filter(Boolean)[0];
+}
+function parseMigrationTarget(args) {
+    if (args.includes("--landlord"))
+        return { scope: "landlord" };
+    if (args.includes("--tenants"))
+        return { scope: "tenants" };
+    const tenantFlagIndex = args.indexOf("--tenant");
+    if (tenantFlagIndex >= 0) {
+        const tenantId = args[tenantFlagIndex + 1];
+        if (!tenantId) {
+            throw new Error("Usage: bun run bunny migrate --tenant <tenantId>");
+        }
+        return { scope: "tenant", tenantId };
+    }
+    return { scope: "default" };
+}
+function createTypeGeneratorOptions(config) {
+    const modelRoots = normalizePathList(config.modelsPath || config.typeDeclarationModelsDir);
+    return {
+        declarations: !config.typeStubs,
+        stubs: config.typeStubs,
+        modelDeclarations: config.typeDeclarations,
+        modelDirectory: modelRoots[0],
+        modelDirectories: modelRoots.length > 1 ? modelRoots : undefined,
+        modelImportPrefix: config.typeDeclarationImportPrefix,
+        singularModels: config.typeDeclarationSingularModels,
+        declarationDirName: "types",
+    };
+}
+async function runMigratorCommand(command, migrator, statusLabel) {
+    if (command === "migrate") {
+        await migrator.run();
+        return;
+    }
+    if (command === "migrate:rollback") {
+        await migrator.rollback();
+        return;
+    }
+    const status = await migrator.status();
+    if (statusLabel) {
+        console.log(statusLabel);
+    }
+    console.table(status);
+}
+async function getTenantIds(config) {
+    if (!config.tenancy?.listTenants) {
+        throw new Error("Tenant migrations require tenancy.listTenants() in bunny.config.ts.");
+    }
+    const tenantIds = await config.tenancy.listTenants();
+    return tenantIds.map((tenantId) => String(tenantId));
+}
+async function runTenantMigrationCommand(command, config, tenantPath, tenantId, typesOutDir) {
+    await TenantContext.run(tenantId, async () => {
+        const context = TenantContext.current();
+        if (!context) {
+            throw new Error(`Tenant "${tenantId}" did not resolve to an active context.`);
+        }
+        console.log(`Tenant: ${tenantId}`);
+        const migrator = new Migrator(context.connection, tenantPath, typesOutDir, createTypeGeneratorOptions(config));
+        await runMigratorCommand(command, migrator);
+    });
+}
+async function runConfiguredMigrationCommand(command, config, connection, target) {
+    if (!config.migrations) {
+        const migrator = new Migrator(connection, getDefaultMigrationsPath(config), config.typesOutDir, createTypeGeneratorOptions(config));
+        await runMigratorCommand(command, migrator);
+        return;
+    }
+    const landlordPath = config.migrations.landlord;
+    const tenantPath = config.migrations.tenant;
+    const runLandlord = async () => {
+        if (!landlordPath)
+            return;
+        console.log("Landlord migrations");
+        const migrator = new Migrator(connection, landlordPath, config.typesOutDir, createTypeGeneratorOptions(config));
+        await runMigratorCommand(command, migrator);
+    };
+    const runAllTenants = async () => {
+        if (!tenantPath)
+            return;
+        if (!config.tenancy?.resolveTenant) {
+            throw new Error("Tenant migrations require tenancy.resolveTenant() in bunny.config.ts.");
+        }
+        ConnectionManager.setTenantResolver(config.tenancy.resolveTenant);
+        const tenantIds = await getTenantIds(config);
+        for (const tenantId of tenantIds) {
+            await runTenantMigrationCommand(command, config, tenantPath, tenantId);
+        }
+    };
+    if (target.scope === "landlord") {
+        await runLandlord();
+        return;
+    }
+    if (target.scope === "tenant") {
+        if (!tenantPath)
+            return;
+        if (!config.tenancy?.resolveTenant) {
+            throw new Error("Tenant migrations require tenancy.resolveTenant() in bunny.config.ts.");
+        }
+        ConnectionManager.setTenantResolver(config.tenancy.resolveTenant);
+        await runTenantMigrationCommand(command, config, tenantPath, target.tenantId);
+        return;
+    }
+    if (target.scope === "tenants") {
+        await runAllTenants();
+        return;
+    }
+    if (command === "migrate:rollback") {
+        await runAllTenants();
+        await runLandlord();
+        return;
+    }
+    await runLandlord();
+    await runAllTenants();
+}
 async function createReplBootstrap(config) {
     const tmpRoot = process.env.BUNNY_REPL_TMPDIR || "/private/tmp";
     const dir = join(tmpRoot, "bunny-repl");
@@ -254,8 +377,8 @@ async function main() {
         }
         const config = await loadConfig();
         const creator = new MigrationCreator();
-        const migrationRoots = normalizePathList(config.migrationsPath);
-        const targetPath = args[2] || migrationRoots[0] || "./database/migrations";
+        const migrationRoots = normalizePathList(config.migrationsPath || config.migrations?.landlord);
+        const targetPath = args[2] || migrationRoots[0] || getFirstMigrationPath(config.migrations?.landlord) || "./database/migrations";
         const path = await creator.create(name, targetPath);
         console.log(`Created migration: ${path}`);
         return;
@@ -290,31 +413,22 @@ async function main() {
         process.exit(exitCode);
     }
     const config = await loadConfig();
-    const connection = new Connection(config.connection);
-    const modelRoots = normalizePathList(config.modelsPath || config.typeDeclarationModelsDir);
-    const migrator = new Migrator(connection, config.migrationsPath, config.typesOutDir, {
-        declarations: !config.typeStubs,
-        stubs: config.typeStubs,
-        modelDeclarations: config.typeDeclarations,
-        modelDirectory: modelRoots[0],
-        modelDirectories: modelRoots.length > 1 ? modelRoots : undefined,
-        modelImportPrefix: config.typeDeclarationImportPrefix,
-        singularModels: config.typeDeclarationSingularModels,
-        declarationDirName: "types",
-    });
+    const { connection } = configureBunny(config);
     if (command === "migrate") {
-        await migrator.run();
+        await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
     }
     else if (command === "migrate:rollback") {
-        await migrator.rollback();
+        await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
     }
     else if (command === "migrate:status") {
-        const status = await migrator.status();
-        console.table(status);
+        await runConfiguredMigrationCommand(command, config, connection, parseMigrationTarget(args.slice(1)));
     }
     else {
         console.log("Usage:");
-        console.log("  bun run bunny migrate              Run pending migrations");
+        console.log("  bun run bunny migrate              Run landlord migrations, then all tenant migrations when configured");
+        console.log("  bun run bunny migrate --landlord   Run landlord migrations only");
+        console.log("  bun run bunny migrate --tenants    Run all tenant migrations only");
+        console.log("  bun run bunny migrate --tenant <id> Run one tenant's migrations only");
         console.log("  bun run bunny migrate:make <name> [dir] Create a new migration");
         console.log("  bun run bunny migrate:rollback     Rollback the last batch");
         console.log("  bun run bunny migrate:status       Show migration status");

package/dist/src/config/BunnyConfig.d.ts

@@ -0,0 +1,28 @@
+import { Connection } from "../connection/Connection.js";
+import type { TenantResolver } from "../connection/ConnectionManager.js";
+import type { ModelDeclaration } from "../typegen/TypeGenerator.js";
+import type { ConnectionConfig } from "../types/index.js";
+export interface BunnyConfig {
+    connection: ConnectionConfig;
+    migrationsPath?: string | string[];
+    migrations?: {
+        landlord?: string | string[];
+        tenant?: string | string[];
+    };
+    tenancy?: {
+        resolveTenant?: TenantResolver;
+        listTenants?: () => string[] | Promise<string[]>;
+    };
+    modelsPath?: string | string[];
+    typesOutDir?: string;
+    typeDeclarations?: Record<string, string | ModelDeclaration>;
+    typeDeclarationModelsDir?: string;
+    typeDeclarationImportPrefix?: string;
+    typeDeclarationSingularModels?: boolean;
+    typeStubs?: boolean;
+}
+export interface ConfiguredBunny {
+    config: BunnyConfig;
+    connection: Connection;
+}
+export declare function configureBunny(config: BunnyConfig): ConfiguredBunny;

package/dist/src/config/BunnyConfig.js

@@ -0,0 +1,14 @@
+import { Connection } from "../connection/Connection.js";
+import { ConnectionManager } from "../connection/ConnectionManager.js";
+import { Model } from "../model/Model.js";
+import { Schema } from "../schema/Schema.js";
+export function configureBunny(config) {
+    const connection = new Connection(config.connection);
+    ConnectionManager.setDefault(connection);
+    Model.setConnection(connection);
+    Schema.setConnection(connection);
+    if (config.tenancy?.resolveTenant) {
+        ConnectionManager.setTenantResolver(config.tenancy.resolveTenant);
+    }
+    return { config, connection };
+}

package/dist/src/connection/Connection.d.ts

@@ -1,13 +1,32 @@
 import { SQL } from "bun";
 import type { ConnectionConfig } from "../types/index.js";
+import { Grammar } from "../query/grammars/Grammar.js";
 export declare class Connection {
     readonly driver: SQL;
     private driverName;
-    constructor(config: ConnectionConfig);
+    private grammar;
+    private config;
+    private schema?;
+    private ownsDriver;
+    constructor(config: ConnectionConfig, options?: {
+        driver?: SQL;
+        schema?: string;
+        ownsDriver?: boolean;
+    });
     getDriverName(): "sqlite" | "mysql" | "postgres";
+    getGrammar(): Grammar;
+    getSchema(): string | undefined;
+    withSchema(schema: string): Connection;
+    withoutSchema(): Connection;
+    qualifyTable(table: string): string;
+    private quoteIdentifier;
     query(sqlString: string): Promise<any[]>;
     run(sqlString: string): Promise<any>;
     beginTransaction(): Promise<void>;
     commit(): Promise<void>;
     rollback(): Promise<void>;
+    transaction<T>(callback: (connection: Connection) => T | Promise<T>): Promise<T>;
+    withTenant<T>(tenantId: string, callback: (connection: Connection) => T | Promise<T>, setting?: string): Promise<T>;
+    withSearchPath<T>(schema: string, callback: (connection: Connection) => T | Promise<T>): Promise<T>;
+    close(): Promise<void>;
 }

package/dist/src/connection/Connection.js

@@ -1,8 +1,18 @@
 import { SQL } from "bun";
+import { SQLiteGrammar } from "../query/grammars/SQLiteGrammar.js";
+import { MySqlGrammar } from "../query/grammars/MySqlGrammar.js";
+import { PostgresGrammar } from "../query/grammars/PostgresGrammar.js";
 export class Connection {
     driver;
     driverName;
-    constructor(config) {
+    grammar;
+    config;
+    schema;
+    ownsDriver;
+    constructor(config, options = {}) {
+        this.config = config;
+        this.schema = options.schema || ("schema" in config ? config.schema : undefined);
+        this.ownsDriver = options.ownsDriver ?? !options.driver;
         let url;
         if ("url" in config && config.url) {
             url = config.url;
@@ -20,16 +30,51 @@ export class Connection {
         else {
             throw new Error("Invalid connection configuration. Provide a url or driver config.");
         }
-        this.driver = new SQL(url);
+        this.driver = options.driver || new SQL(url);
         this.driverName = url.startsWith("sqlite")
             ? "sqlite"
             : url.startsWith("mysql")
                 ? "mysql"
                 : "postgres";
+        switch (this.driverName) {
+            case "sqlite":
+                this.grammar = new SQLiteGrammar();
+                break;
+            case "mysql":
+                this.grammar = new MySqlGrammar();
+                break;
+            case "postgres":
+                this.grammar = new PostgresGrammar();
+                break;
+        }
     }
     getDriverName() {
         return this.driverName;
     }
+    getGrammar() {
+        return this.grammar;
+    }
+    getSchema() {
+        return this.schema;
+    }
+    withSchema(schema) {
+        if (this.schema === schema)
+            return this;
+        return new Connection(this.config, { driver: this.driver, schema, ownsDriver: false });
+    }
+    withoutSchema() {
+        if (!this.schema)
+            return this;
+        return new Connection(this.config, { driver: this.driver, ownsDriver: false });
+    }
+    qualifyTable(table) {
+        if (!this.schema || this.driverName === "sqlite" || table.includes("."))
+            return table;
+        return `${this.schema}.${table}`;
+    }
+    quoteIdentifier(value) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
     async query(sqlString) {
         // Use unsafe for generated SQL strings
         return (await this.driver.unsafe(sqlString));
@@ -46,4 +91,37 @@ export class Connection {
     async rollback() {
         await this.driver.unsafe("ROLLBACK");
     }
+    async transaction(callback) {
+        return await this.driver.begin(async (sql) => {
+            const connection = new Connection(this.config, {
+                driver: sql,
+                schema: this.schema,
+                ownsDriver: false,
+            });
+            return await callback(connection);
+        });
+    }
+    async withTenant(tenantId, callback, setting = "app.tenant_id") {
+        if (this.driverName !== "postgres") {
+            return await this.transaction(callback);
+        }
+        return await this.transaction(async (connection) => {
+            await connection.run(`SET LOCAL ${setting} = ${connection.getGrammar().escape(tenantId)}`);
+            return await callback(connection);
+        });
+    }
+    async withSearchPath(schema, callback) {
+        if (this.driverName !== "postgres") {
+            throw new Error("search_path schema switching is only supported for PostgreSQL connections.");
+        }
+        return await this.transaction(async (connection) => {
+            await connection.run(`SET LOCAL search_path TO ${connection.quoteIdentifier(schema)}`);
+            return await callback(connection.withoutSchema());
+        });
+    }
+    async close() {
+        if (this.ownsDriver) {
+            await this.driver.close();
+        }
+    }
 }

package/dist/src/connection/ConnectionManager.d.ts

@@ -0,0 +1,40 @@
+import { Connection } from "./Connection.js";
+import type { ConnectionConfig } from "../types/index.js";
+import type { ActiveTenantContext } from "./TenantContext.js";
+export type TenantResolution = {
+    strategy: "database";
+    name: string;
+    config: ConnectionConfig;
+} | {
+    strategy: "schema";
+    name: string;
+    config?: ConnectionConfig;
+    connection?: string | Connection;
+    schema: string;
+    mode?: "qualify" | "search_path";
+} | {
+    strategy: "rls";
+    name: string;
+    config?: ConnectionConfig;
+    connection?: string | Connection;
+    tenantId?: string;
+    setting?: string;
+};
+export type TenantResolver = (tenantId: string) => TenantResolution | Promise<TenantResolution>;
+export declare class ConnectionManager {
+    private static defaultConnection?;
+    private static connections;
+    private static tenantResolver?;
+    private static tenantCache;
+    static setDefault(connection: Connection): void;
+    static getDefault(): Connection | undefined;
+    static add(name: string, connection: Connection | ConnectionConfig): Connection;
+    static get(name: string): Connection | undefined;
+    static require(name: string): Connection;
+    static setTenantResolver(resolver: TenantResolver): void;
+    static resolveTenant(tenantId: string): Promise<ActiveTenantContext>;
+    static getResolvedTenant(tenantId: string): ActiveTenantContext | undefined;
+    static purgeTenant(tenantId: string): void;
+    static closeTenant(tenantId: string): Promise<void>;
+    static closeAll(): Promise<void>;
+}

package/dist/src/connection/ConnectionManager.js

@@ -0,0 +1,104 @@
+import { Connection } from "./Connection.js";
+export class ConnectionManager {
+    static defaultConnection;
+    static connections = new Map();
+    static tenantResolver;
+    static tenantCache = new Map();
+    static setDefault(connection) {
+        this.defaultConnection = connection;
+    }
+    static getDefault() {
+        return this.defaultConnection;
+    }
+    static add(name, connection) {
+        const resolved = connection instanceof Connection ? connection : new Connection(connection);
+        this.connections.set(name, resolved);
+        return resolved;
+    }
+    static get(name) {
+        return this.connections.get(name);
+    }
+    static require(name) {
+        const connection = this.get(name);
+        if (!connection) {
+            throw new Error(`No connection registered for "${name}".`);
+        }
+        return connection;
+    }
+    static setTenantResolver(resolver) {
+        this.tenantResolver = resolver;
+        this.tenantCache.clear();
+    }
+    static async resolveTenant(tenantId) {
+        const cached = this.tenantCache.get(tenantId);
+        if (cached)
+            return cached;
+        if (!this.tenantResolver) {
+            throw new Error("No tenant resolver configured.");
+        }
+        const resolution = await this.tenantResolver(tenantId);
+        const schema = resolution.strategy === "schema" ? resolution.schema : undefined;
+        const schemaMode = resolution.strategy === "schema" ? resolution.mode || "qualify" : undefined;
+        let connection = (resolution.strategy === "schema" || resolution.strategy === "rls") && resolution.connection instanceof Connection
+            ? resolution.connection
+            : (resolution.strategy === "schema" || resolution.strategy === "rls") && typeof resolution.connection === "string"
+                ? this.require(resolution.connection)
+                : this.connections.get(resolution.name);
+        if (!connection) {
+            if ((resolution.strategy === "schema" || resolution.strategy === "rls") && !resolution.config) {
+                connection = this.defaultConnection;
+            }
+            if (!connection && !resolution.config) {
+                throw new Error(`No connection config or registered connection found for tenant "${tenantId}".`);
+            }
+        }
+        if (!connection) {
+            const config = resolution.config;
+            if (!config) {
+                throw new Error(`No connection config or registered connection found for tenant "${tenantId}".`);
+            }
+            connection = new Connection(config, { schema });
+            this.connections.set(resolution.name, connection);
+        }
+        else if (schema && schemaMode === "qualify") {
+            connection = connection.withSchema(schema);
+        }
+        const context = {
+            tenantId,
+            connection,
+            connectionName: resolution.name,
+            strategy: resolution.strategy,
+            schema,
+            schemaMode,
+            rlsTenantId: resolution.strategy === "rls" ? resolution.tenantId || tenantId : undefined,
+            rlsSetting: resolution.strategy === "rls" ? resolution.setting || "app.tenant_id" : undefined,
+        };
+        this.tenantCache.set(tenantId, context);
+        return context;
+    }
+    static getResolvedTenant(tenantId) {
+        return this.tenantCache.get(tenantId);
+    }
+    static purgeTenant(tenantId) {
+        this.tenantCache.delete(tenantId);
+    }
+    static async closeTenant(tenantId) {
+        const context = this.tenantCache.get(tenantId);
+        if (!context)
+            return;
+        this.tenantCache.delete(tenantId);
+        const connection = this.connections.get(context.connectionName);
+        this.connections.delete(context.connectionName);
+        await connection?.close();
+    }
+    static async closeAll() {
+        const connections = new Set(this.connections.values());
+        if (this.defaultConnection)
+            connections.add(this.defaultConnection);
+        this.connections.clear();
+        this.tenantCache.clear();
+        for (const connection of connections) {
+            await connection.close();
+        }
+    }
+}

package/dist/src/connection/TenantContext.d.ts

@@ -0,0 +1,15 @@
+import type { Connection } from "./Connection.js";
+export interface ActiveTenantContext {
+    tenantId: string;
+    connection: Connection;
+    connectionName: string;
+    strategy: "database" | "schema" | "rls";
+    schema?: string;
+    schemaMode?: "qualify" | "search_path";
+    rlsTenantId?: string;
+    rlsSetting?: string;
+}
+export declare class TenantContext {
+    static current(): ActiveTenantContext | undefined;
+    static run<T>(tenantId: string, callback: () => T | Promise<T>): Promise<T>;
+}

package/dist/src/connection/TenantContext.js

@@ -0,0 +1,22 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+import { ConnectionManager } from "./ConnectionManager.js";
+const storage = new AsyncLocalStorage();
+export class TenantContext {
+    static current() {
+        return storage.getStore();
+    }
+    static async run(tenantId, callback) {
+        const context = await ConnectionManager.resolveTenant(tenantId);
+        if (context.strategy === "schema" && context.schema && context.schemaMode === "search_path") {
+            return await context.connection.withSearchPath(context.schema, async (connection) => {
+                return await storage.run({ ...context, connection }, callback);
+            });
+        }
+        if (context.strategy === "rls") {
+            return await context.connection.withTenant(context.rlsTenantId || context.tenantId, async (connection) => {
+                return await storage.run({ ...context, connection }, callback);
+            }, context.rlsSetting);
+        }
+        return await storage.run(context, callback);
+    }
+}

package/dist/src/index.d.ts

@@ -1,4 +1,10 @@
 export { Connection } from "./connection/Connection.js";
+export { ConnectionManager } from "./connection/ConnectionManager.js";
+export type { TenantResolution, TenantResolver } from "./connection/ConnectionManager.js";
+export { TenantContext } from "./connection/TenantContext.js";
+export type { ActiveTenantContext } from "./connection/TenantContext.js";
+export { configureBunny } from "./config/BunnyConfig.js";
+export type { BunnyConfig, ConfiguredBunny } from "./config/BunnyConfig.js";
 export type { ConnectionConfig } from "./types/index.js";
 export { Schema } from "./schema/Schema.js";
 export { Blueprint } from "./schema/Blueprint.js";

package/dist/src/index.js

@@ -1,4 +1,7 @@
 export { Connection } from "./connection/Connection.js";
+export { ConnectionManager } from "./connection/ConnectionManager.js";
+export { TenantContext } from "./connection/TenantContext.js";
+export { configureBunny } from "./config/BunnyConfig.js";
 export { Schema } from "./schema/Schema.js";
 export { Blueprint } from "./schema/Blueprint.js";
 export { Grammar } from "./schema/grammars/Grammar.js";

package/dist/src/model/BelongsToMany.js

@@ -21,7 +21,7 @@ export class BelongsToMany {
         this.relatedKey = relatedKey || related.primaryKey;
         this.foreignPivotKey = foreignPivotKey || `${snakeCase(parent.constructor.name)}_id`;
         this.relatedPivotKey = relatedPivotKey || `${snakeCase(related.name)}_id`;
-        this.builder = related.query();
+        this.builder = related.on(parent.getConnection());
         this.addConstraints();
     }
     addConstraints() {
@@ -35,7 +35,7 @@ export class BelongsToMany {
     }
     addEagerConstraints(models) {
         const keys = models.map((m) => m.getAttribute(this.parentKey));
-        this.builder = this.related.query();
+        this.builder = this.related.on(this.parent.getConnection());
         const relatedTable = this.related.getTable();
         this.builder.select(`${relatedTable}.*`, `${this.table}.${this.foreignPivotKey}`);
         this.builder.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
@@ -66,7 +66,7 @@ export class BelongsToMany {
     }
     newExistenceQuery(parentTable, aggregate, callback) {
         const relatedTable = this.related.getTable();
-        const query = this.related.query().select(aggregate);
+        const query = this.related.on(this.parent.getConnection()).select(aggregate);
         query.join(this.table, `${this.table}.${this.relatedPivotKey}`, "=", `${relatedTable}.${this.relatedKey}`);
         query.whereColumn(`${this.table}.${this.foreignPivotKey}`, "=", `${parentTable}.${this.parentKey}`);
         if (callback)
@@ -89,10 +89,12 @@ export class BelongsToMany {
             [this.relatedPivotKey]: id,
             ...attributes,
         }));
-        await new Builder(this.related.getConnection(), this.table).insert(records);
+        const connection = this.parent.getConnection();
+        await new Builder(connection, connection.qualifyTable(this.table)).insert(records);
     }
     async detach(ids) {
-        const builder = new Builder(this.related.getConnection(), this.table)
+        const connection = this.parent.getConnection();
+        const builder = new Builder(connection, connection.qualifyTable(this.table))
             .where(this.foreignPivotKey, this.parent.getAttribute(this.parentKey));
         if (ids !== undefined) {
             builder.whereIn(this.relatedPivotKey, Array.isArray(ids) ? ids : [ids]);
@@ -101,7 +103,8 @@ export class BelongsToMany {
     }
     async sync(ids, detachMissing = true) {
         const idList = Array.isArray(ids) ? ids : [ids];
-        const current = await new Builder(this.related.getConnection(), this.table)
+        const connection = this.parent.getConnection();
+        const current = await new Builder(connection, connection.qualifyTable(this.table))
             .where(this.foreignPivotKey, this.parent.getAttribute(this.parentKey))
             .pluck(this.relatedPivotKey);
         const currentSet = new Set(current);

package/dist/src/model/Model.d.ts

@@ -97,10 +97,13 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     $exists: boolean;
     $relations: Record<string, any>;
     $casts: Record<string, CastDefinition>;
+    $connection?: Connection;
     constructor(attributes?: Partial<T>);
     static getTable(): string;
     static getConnection(): Connection;
     static setConnection(connection: Connection): void;
+    static on<M extends typeof Model>(this: M, connection: string | Connection): Builder<InstanceType<M>>;
+    static forTenant<M extends typeof Model>(this: M, tenantId: string): Builder<InstanceType<M>>;
     static query<M extends typeof Model>(this: M): Builder<InstanceType<M>>;
     static addGlobalScope(name: string, scope: GlobalScope): void;
     static removeGlobalScope(name: string): void;
@@ -165,6 +168,8 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static eagerLoadRelations(models: Model[], relations: string[]): Promise<void>;
     static eagerLoadRelation(models: Model[], relationName: string): Promise<void>;
     fill(attributes: Partial<T>): this;
+    setConnection(connection: Connection): this;
+    getConnection(): Connection;
     isFillable(key: string): boolean;
     getAttribute<K extends keyof T>(key: K): T[K];
     getAttribute(key: string): any;