@bunnykit/orm 0.1.24 → 0.1.25

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

@@ -18,10 +18,13 @@ export declare class Connection {
     getDriverName(): "sqlite" | "mysql" | "postgres";
     getGrammar(): Grammar;
     getSchema(): string | undefined;
+    static isSafeIdentifier(value: string): boolean;
+    static assertSafeIdentifier(value: string, label?: string): void;
+    static assertSafeQualifiedIdentifier(value: string, label?: string): void;
     withSchema(schema: string): Connection;
     withoutSchema(): Connection;
     qualifyTable(table: string): string;
-    private quoteIdentifier;
+    quoteIdentifier(value: string): string;
     query(sqlString: string, bindings?: any[]): Promise<any[]>;
     run(sqlString: string, bindings?: any[]): Promise<any>;
     beginTransaction(): Promise<void>;

package/dist/src/connection/Connection.js

@@ -59,7 +59,22 @@ export class Connection {
     getSchema() {
         return this.schema;
     }
+    static isSafeIdentifier(value) {
+        return /^[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+    }
+    static assertSafeIdentifier(value, label = "identifier") {
+        if (!this.isSafeIdentifier(value)) {
+            throw new Error(`Invalid ${label}: ${value}`);
+        }
+    }
+    static assertSafeQualifiedIdentifier(value, label = "identifier") {
+        const parts = value.split(".");
+        if (parts.length === 0 || parts.some((part) => !this.isSafeIdentifier(part))) {
+            throw new Error(`Invalid ${label}: ${value}`);
+        }
+    }
     withSchema(schema) {
+        Connection.assertSafeIdentifier(schema, "schema name");
         if (this.schema === schema)
             return this;
         return new Connection(this.config, { driver: this.driver, schema, ownsDriver: false });
@@ -70,8 +85,14 @@ export class Connection {
         return new Connection(this.config, { driver: this.driver, ownsDriver: false });
     }
     qualifyTable(table) {
-        if (!this.schema || this.driverName === "sqlite" || table.includes("."))
+        if (table.includes(".")) {
+            Connection.assertSafeQualifiedIdentifier(table, "qualified table name");
+            return table;
+        }
+        if (!this.schema || this.driverName === "sqlite")
             return table;
+        Connection.assertSafeIdentifier(this.schema, "schema name");
+        Connection.assertSafeIdentifier(table, "table name");
         return `${this.schema}.${table}`;
     }
     quoteIdentifier(value) {
@@ -144,6 +165,7 @@ export class Connection {
         if (this.driverName !== "postgres") {
             throw new Error("search_path schema switching is only supported for PostgreSQL connections.");
         }
+        Connection.assertSafeIdentifier(schema, "schema name");
         return await this.transaction(async (connection) => {
             await connection.run(`SET LOCAL search_path TO ${connection.quoteIdentifier(schema)}`);
             return await callback(connection.withoutSchema());

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

@@ -1,25 +1,32 @@
 import { Connection } from "./Connection.js";
 import type { ConnectionConfig } from "../types/index.js";
 import type { ActiveTenantContext } from "./TenantContext.js";
-export type TenantResolution = {
+export interface TenantCachePolicy {
+    ttl?: number;
+    closeOnPurge?: boolean;
+}
+type TenantResolutionOptions = TenantCachePolicy & {
+    cache?: TenantCachePolicy;
+};
+export type TenantResolution = ({
     strategy: "database";
     name: string;
     config: ConnectionConfig;
-} | {
+} & TenantResolutionOptions) | ({
     strategy: "schema";
     name: string;
     config?: ConnectionConfig;
     connection?: string | Connection;
     schema: string;
     mode?: "qualify" | "search_path";
-} | {
+} & TenantResolutionOptions) | ({
     strategy: "rls";
     name: string;
     config?: ConnectionConfig;
     connection?: string | Connection;
     tenantId?: string;
     setting?: string;
-};
+} & TenantResolutionOptions);
 export type TenantResolver = (tenantId: string) => TenantResolution | Promise<TenantResolution>;
 export interface PoolConfig {
     maxConnections?: number;
@@ -50,6 +57,10 @@ export declare class ConnectionManager {
     static resolveTenant(tenantId: string): Promise<ActiveTenantContext>;
     static getResolvedTenant(tenantId: string): ActiveTenantContext | undefined;
     static purgeTenant(tenantId: string): void;
+    static purgeExpiredTenants(options?: {
+        close?: boolean;
+    }): Promise<string[]>;
     static closeTenant(tenantId: string): Promise<void>;
     static closeAll(): Promise<void>;
 }
+export {};

package/dist/src/connection/ConnectionManager.js

@@ -139,14 +139,20 @@ export class ConnectionManager {
     }
     static async resolveTenant(tenantId) {
         const cached = this.tenantCache.get(tenantId);
-        if (cached)
-            return cached;
+        if (cached) {
+            if (!cached.expiresAt || cached.expiresAt > Date.now())
+                return cached;
+            await this.closeTenant(tenantId);
+        }
         if (!this.tenantResolver) {
             throw new Error("No tenant resolver configured.");
         }
         const resolution = await this.tenantResolver(tenantId);
+        const policy = { ...resolution.cache, ttl: resolution.ttl ?? resolution.cache?.ttl, closeOnPurge: resolution.closeOnPurge ?? resolution.cache?.closeOnPurge };
+        const resolvedAt = Date.now();
         const schema = resolution.strategy === "schema" ? resolution.schema : undefined;
         const schemaMode = resolution.strategy === "schema" ? resolution.mode || "qualify" : undefined;
+        let ownsConnection = false;
         let connection = (resolution.strategy === "schema" || resolution.strategy === "rls") && resolution.connection instanceof Connection
             ? resolution.connection
             : (resolution.strategy === "schema" || resolution.strategy === "rls") && typeof resolution.connection === "string"
@@ -167,6 +173,7 @@ export class ConnectionManager {
             }
             connection = new Connection(config, { schema });
             this.connections.set(resolution.name, connection);
+            ownsConnection = true;
         }
         else if (schema && schemaMode === "qualify") {
             connection = connection.withSchema(schema);
@@ -176,6 +183,10 @@ export class ConnectionManager {
             connection,
             connectionName: resolution.name,
             strategy: resolution.strategy,
+            resolvedAt,
+            expiresAt: policy.ttl ? resolvedAt + policy.ttl : undefined,
+            closeOnPurge: policy.closeOnPurge ?? ownsConnection,
+            ownsConnection,
             schema,
             schemaMode,
             rlsTenantId: resolution.strategy === "rls" ? resolution.tenantId || tenantId : undefined,
@@ -185,19 +196,53 @@ export class ConnectionManager {
         return context;
     }
     static getResolvedTenant(tenantId) {
-        return this.tenantCache.get(tenantId);
+        const context = this.tenantCache.get(tenantId);
+        if (!context || !context.expiresAt || context.expiresAt > Date.now())
+            return context;
+        this.tenantCache.delete(tenantId);
+        return undefined;
     }
     static purgeTenant(tenantId) {
         this.tenantCache.delete(tenantId);
     }
+    static async purgeExpiredTenants(options = {}) {
+        const now = Date.now();
+        const purged = [];
+        for (const [tenantId, context] of [...this.tenantCache.entries()]) {
+            if (!context.expiresAt || context.expiresAt > now)
+                continue;
+            purged.push(tenantId);
+            if (options.close ?? context.closeOnPurge) {
+                await this.closeTenant(tenantId);
+            }
+            else {
+                this.tenantCache.delete(tenantId);
+            }
+        }
+        return purged;
+    }
     static async closeTenant(tenantId) {
         const context = this.tenantCache.get(tenantId);
         if (!context)
             return;
         this.tenantCache.delete(tenantId);
+        if (!context.closeOnPurge)
+            return;
         const connection = this.connections.get(context.connectionName);
-        this.connections.delete(context.connectionName);
-        await connection?.close();
+        if (connection === context.connection) {
+            this.connections.delete(context.connectionName);
+            await connection.close();
+        }
+        else if (context.ownsConnection) {
+            await context.connection.close();
+        }
+        const pool = this.pools.get(context.connectionName);
+        if (pool) {
+            this.pools.delete(context.connectionName);
+            for (const { connection } of pool) {
+                await connection.close().catch(() => null);
+            }
+        }
     }
     static async closeAll() {
         const connections = new Set(this.connections.values());

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

@@ -4,6 +4,10 @@ export interface ActiveTenantContext {
     connection: Connection;
     connectionName: string;
     strategy: "database" | "schema" | "rls";
+    resolvedAt: number;
+    expiresAt?: number;
+    closeOnPurge: boolean;
+    ownsConnection: boolean;
     schema?: string;
     schemaMode?: "qualify" | "search_path";
     rlsTenantId?: string;

package/dist/src/index.d.ts

@@ -1,6 +1,6 @@
 export { Connection } from "./connection/Connection.js";
 export { ConnectionManager } from "./connection/ConnectionManager.js";
-export type { TenantResolution, TenantResolver } from "./connection/ConnectionManager.js";
+export type { TenantCachePolicy, 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";
@@ -23,7 +23,7 @@ export { BelongsToMany } from "./model/BelongsToMany.js";
 export { IdentityMap } from "./model/IdentityMap.js";
 export { Migration } from "./migration/Migration.js";
 export { Migrator } from "./migration/Migrator.js";
-export type { MigrationEvent, MigrationEventListener, MigrationEventPayload } from "./migration/Migrator.js";
+export type { MigrationEvent, MigrationEventListener, MigrationEventPayload, MigrationStatusRow, MigratorOptions } from "./migration/Migrator.js";
 export { MigrationCreator } from "./migration/MigrationCreator.js";
 export { TypeGenerator } from "./typegen/TypeGenerator.js";
 export { TypeMapper } from "./typegen/TypeMapper.js";

package/dist/src/migration/Migrator.d.ts

@@ -1,5 +1,15 @@
 import { Connection } from "../connection/Connection.js";
 import type { TypeGeneratorOptions } from "../typegen/TypeGenerator.js";
+export interface MigrationStatusRow {
+    migration: string;
+    status: string;
+    tenant: string | null;
+}
+export interface MigratorOptions {
+    tenantId?: string | null;
+    lock?: boolean;
+    lockTimeoutMs?: number;
+}
 export type MigrationEvent = "migrating" | "migrated" | "rollingBack" | "rolledBack" | "schemaDumped" | "schemaSquashed";
 export interface MigrationEventPayload {
     migration?: string;
@@ -12,10 +22,18 @@ export declare class Migrator {
     private path;
     private typesOutDir?;
     private typeGeneratorOptions;
+    private options;
     private static listeners;
-    constructor(connection: Connection, path: string | string[], typesOutDir?: string | undefined, typeGeneratorOptions?: Omit<TypeGeneratorOptions, "outDir">);
+    constructor(connection: Connection, path: string | string[], typesOutDir?: string | undefined, typeGeneratorOptions?: Omit<TypeGeneratorOptions, "outDir">, options?: MigratorOptions);
     private getPaths;
     private ensureMigrationsTable;
+    private getTenantId;
+    private scopedMigrations;
+    private ensureMigrationLocksTable;
+    private getLockName;
+    private shouldLock;
+    private acquireLock;
+    private releaseLock;
     static on(event: MigrationEvent, listener: MigrationEventListener): () => void;
     static clearListeners(event?: MigrationEvent): void;
     private emit;
@@ -24,10 +42,7 @@ export declare class Migrator {
     run(): Promise<void>;
     rollback(): Promise<void>;
     private generateTypesIfNeeded;
-    status(): Promise<{
-        migration: string;
-        status: string;
-    }[]>;
+    status(): Promise<MigrationStatusRow[]>;
     dumpSchema(path: string): Promise<string>;
     squash(path: string): Promise<string>;
     private getSchemaDumpSql;

package/dist/src/migration/Migrator.js

@@ -10,12 +10,14 @@ export class Migrator {
     path;
     typesOutDir;
     typeGeneratorOptions;
+    options;
     static listeners = new Map();
-    constructor(connection, path, typesOutDir, typeGeneratorOptions = {}) {
+    constructor(connection, path, typesOutDir, typeGeneratorOptions = {}, options = {}) {
         this.connection = connection;
         this.path = path;
         this.typesOutDir = typesOutDir;
         this.typeGeneratorOptions = typeGeneratorOptions;
+        this.options = options;
         Schema.setConnection(connection);
     }
     getPaths() {
@@ -27,10 +29,73 @@ export class Migrator {
             await Schema.create("migrations", (table) => {
                 table.increments("id");
                 table.string("migration");
+                table.string("tenant").nullable().index();
                 table.integer("batch");
             });
+            return;
+        }
+        if (!(await Schema.hasColumn("migrations", "tenant"))) {
+            await Schema.table("migrations", (table) => {
+                table.string("tenant").nullable().index();
+            });
+        }
+    }
+    getTenantId() {
+        return this.options.tenantId ?? null;
+    }
+    scopedMigrations() {
+        const builder = new Builder(this.connection, "migrations");
+        const tenantId = this.getTenantId();
+        return tenantId === null ? builder.whereNull("tenant") : builder.where("tenant", tenantId);
+    }
+    async ensureMigrationLocksTable() {
+        if (await Schema.hasTable("migration_locks"))
+            return;
+        await Schema.create("migration_locks", (table) => {
+            table.string("name").primary();
+            table.string("owner");
+            table.string("created_at");
+        });
+    }
+    getLockName() {
+        const tenantId = this.getTenantId();
+        return tenantId === null ? "migrations:default" : `migrations:tenant:${tenantId}`;
+    }
+    shouldLock() {
+        return this.options.lock !== false;
+    }
+    async acquireLock() {
+        if (!this.shouldLock())
+            return false;
+        await this.ensureMigrationLocksTable();
+        const lockName = this.getLockName();
+        const timeoutMs = this.options.lockTimeoutMs ?? 30000;
+        const owner = `${process.pid}:${Date.now()}:${Math.random().toString(36).slice(2)}`;
+        const started = Date.now();
+        while (true) {
+            try {
+                await new Builder(this.connection, "migration_locks").insert({
+                    name: lockName,
+                    owner,
+                    created_at: new Date().toISOString(),
+                });
+                return true;
+            }
+            catch {
+                if (Date.now() - started >= timeoutMs) {
+                    throw new Error(`Could not acquire migration lock "${lockName}" within ${timeoutMs}ms.`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, 50));
+            }
         }
     }
+    async releaseLock() {
+        if (!this.shouldLock())
+            return;
+        await new Builder(this.connection, "migration_locks")
+            .where("name", this.getLockName())
+            .delete();
+    }
     static on(event, listener) {
         const listeners = this.listeners.get(event) || new Set();
         listeners.add(listener);
@@ -49,7 +114,8 @@ export class Migrator {
         }
     }
     async getLastBatchNumber() {
-        const result = await new Builder(this.connection, "migrations")
+        await this.ensureMigrationsTable();
+        const result = await this.scopedMigrations()
             .select("MAX(batch) as batch")
             .first();
         return result?.batch || 0;
@@ -74,16 +140,18 @@ export class Migrator {
         return files.sort((a, b) => a.fileName.localeCompare(b.fileName) || a.id.localeCompare(b.id));
     }
     async run() {
-        const ran = await this.getRan();
-        const files = await this.getMigrationFiles();
-        const pending = files.filter((f) => !ran.has(f.id) && !ran.has(f.fileName));
-        if (pending.length === 0) {
-            console.log("Nothing to migrate.");
-            return;
-        }
-        const batch = (await this.getLastBatchNumber()) + 1;
-        await this.connection.beginTransaction();
+        await this.ensureMigrationsTable();
+        const locked = await this.acquireLock();
         try {
+            const ran = await this.getRan();
+            const files = await this.getMigrationFiles();
+            const pending = files.filter((f) => !ran.has(f.id) && !ran.has(f.fileName));
+            if (pending.length === 0) {
+                console.log("Nothing to migrate.");
+                return;
+            }
+            const batch = (await this.getLastBatchNumber()) + 1;
+            await this.connection.beginTransaction();
             for (const file of pending) {
                 const migration = await this.resolve(file.id);
                 console.log(`Migrating: ${file.id}`);
@@ -91,6 +159,7 @@ export class Migrator {
                 await migration.up();
                 await new Builder(this.connection, "migrations").insert({
                     migration: file.id,
+                    tenant: this.getTenantId(),
                     batch,
                 });
                 await this.emit("migrated", { migration: file.id, batch });
@@ -103,23 +172,29 @@ export class Migrator {
             await this.connection.rollback();
             throw error;
         }
+        finally {
+            if (locked)
+                await this.releaseLock();
+        }
     }
     async rollback() {
-        const batch = await this.getLastBatchNumber();
-        if (batch === 0) {
-            console.log("Nothing to rollback.");
-            return;
-        }
-        const records = (await new Builder(this.connection, "migrations")
-            .where("batch", batch)
-            .orderBy("id", "desc")
-            .get());
-        if (records.length === 0) {
-            console.log("Nothing to rollback.");
-            return;
-        }
-        await this.connection.beginTransaction();
+        await this.ensureMigrationsTable();
+        const locked = await this.acquireLock();
         try {
+            const batch = await this.getLastBatchNumber();
+            if (batch === 0) {
+                console.log("Nothing to rollback.");
+                return;
+            }
+            const records = (await this.scopedMigrations()
+                .where("batch", batch)
+                .orderBy("id", "desc")
+                .get());
+            if (records.length === 0) {
+                console.log("Nothing to rollback.");
+                return;
+            }
+            await this.connection.beginTransaction();
             for (const record of records) {
                 const migration = await this.resolve(record.migration);
                 console.log(`Rolling back: ${record.migration}`);
@@ -138,6 +213,10 @@ export class Migrator {
             await this.connection.rollback();
             throw error;
         }
+        finally {
+            if (locked)
+                await this.releaseLock();
+        }
     }
     async generateTypesIfNeeded() {
         const modelDirectories = normalizePathList(this.typeGeneratorOptions.modelDirectories || this.typeGeneratorOptions.modelDirectory);
@@ -154,11 +233,14 @@ export class Migrator {
         console.log(`Regenerated types in ${label}`);
     }
     async status() {
+        await this.ensureMigrationsTable();
         const ran = await this.getRan();
         const files = await this.getMigrationFiles();
+        const tenant = this.getTenantId();
         return files.map((file) => ({
             migration: file.id,
             status: ran.has(file.id) || ran.has(file.fileName) ? "Ran" : "Pending",
+            tenant,
         }));
     }
     async dumpSchema(path) {
@@ -173,12 +255,20 @@ export class Migrator {
         const files = await this.getMigrationFiles();
         await this.ensureMigrationsTable();
         const batch = (await this.getLastBatchNumber()) + 1;
-        await new Builder(this.connection, "migrations").delete();
-        for (const file of files) {
-            await new Builder(this.connection, "migrations").insert({
-                migration: file.id,
-                batch,
-            });
+        const locked = await this.acquireLock();
+        try {
+            await this.scopedMigrations().delete();
+            for (const file of files) {
+                await new Builder(this.connection, "migrations").insert({
+                    migration: file.id,
+                    tenant: this.getTenantId(),
+                    batch,
+                });
+            }
+        }
+        finally {
+            if (locked)
+                await this.releaseLock();
         }
         await this.emit("schemaSquashed", { path, batch });
         return sql;
@@ -269,7 +359,7 @@ export class Migrator {
     }
     async getRan() {
         await this.ensureMigrationsTable();
-        const results = await new Builder(this.connection, "migrations")
+        const results = await this.scopedMigrations()
             .orderBy("id", "asc")
             .get();
         const ran = new Set();

package/dist/src/schema/Schema.d.ts

@@ -7,6 +7,10 @@ export declare class Schema {
     private static getGrammar;
     static create(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
     static createIfNotExists(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
+    static createSchema(schema: string): Promise<void>;
+    static dropSchema(schema: string, options?: {
+        cascade?: boolean;
+    }): Promise<void>;
     static table(table: string, callback: (blueprint: Blueprint) => void): Promise<void>;
     static drop(table: string): Promise<void>;
     static dropIfExists(table: string): Promise<void>;

package/dist/src/schema/Schema.js

@@ -1,3 +1,4 @@
+import { Connection } from "../connection/Connection.js";
 import { Blueprint } from "./Blueprint.js";
 import { SQLiteGrammar } from "./grammars/SQLiteGrammar.js";
 import { MySqlGrammar } from "./grammars/MySqlGrammar.js";
@@ -61,6 +62,29 @@ export class Schema {
             await this.getConnection().run(fkSql);
         }
     }
+    static async createSchema(schema) {
+        Connection.assertSafeIdentifier(schema, "schema name");
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        if (driver === "sqlite") {
+            throw new Error("Schema creation is not supported for SQLite connections.");
+        }
+        const grammar = this.getGrammar();
+        const keyword = driver === "mysql" ? "DATABASE" : "SCHEMA";
+        await connection.run(`CREATE ${keyword} IF NOT EXISTS ${grammar.wrap(schema)}`);
+    }
+    static async dropSchema(schema, options = {}) {
+        Connection.assertSafeIdentifier(schema, "schema name");
+        const connection = this.getConnection();
+        const driver = connection.getDriverName();
+        if (driver === "sqlite") {
+            throw new Error("Schema dropping is not supported for SQLite connections.");
+        }
+        const grammar = this.getGrammar();
+        const keyword = driver === "mysql" ? "DATABASE" : "SCHEMA";
+        const cascade = driver === "postgres" && options.cascade ? " CASCADE" : "";
+        await connection.run(`DROP ${keyword} IF EXISTS ${grammar.wrap(schema)}${cascade}`);
+    }
     static async table(table, callback) {
         const blueprint = new Blueprint(table);
         callback(blueprint);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bunnykit/orm",
-  "version": "0.1.24",
+  "version": "0.1.25",
   "description": "An Eloquent-inspired ORM for Bun's native SQL client supporting SQLite, MySQL, and PostgreSQL.",
   "license": "MIT",
   "packageManager": "bun@1.3.12",