@bunnykit/orm 0.1.23 → 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/model/Model.d.ts

@@ -5,7 +5,7 @@ import { BelongsToMany } from "./BelongsToMany.js";
 export type ModelConstructor<T extends Model = Model> = (new (...args: any[]) => T) & Omit<typeof Model, "prototype">;
 export type GlobalScope = (builder: Builder<any>, model: ModelConstructor) => void;
 export type LiteralUnion<T extends string> = T | (string & {});
-type BaseModelInstanceKey = "$attributes" | "$original" | "$exists" | "$relations" | "$casts" | "$connection" | "fill" | "setConnection" | "getConnection" | "isFillable" | "getAttribute" | "setAttribute" | "castAttribute" | "serializeCastAttribute" | "mergeCasts" | "getDirty" | "isDirty" | "save" | "updateTimestamps" | "touch" | "increment" | "decrement" | "load" | "delete" | "restore" | "forceDelete" | "refresh" | "toJSON" | "toString" | "freshTimestamp" | "setRelation" | "getRelation" | "hasMany" | "belongsTo" | "hasOne" | "hasManyThrough" | "hasOneThrough" | "belongsToMany" | "morphTo" | "morphOne" | "morphMany" | "morphToMany" | "morphedByMany";
+type BaseModelInstanceKey = "$attributes" | "$original" | "$exists" | "$relations" | "$casts" | "$castCache" | "$connection" | "fill" | "setConnection" | "getConnection" | "isFillable" | "getAttribute" | "setAttribute" | "castAttribute" | "serializeCastAttribute" | "mergeCasts" | "getDirty" | "isDirty" | "save" | "updateTimestamps" | "touch" | "increment" | "decrement" | "load" | "delete" | "restore" | "forceDelete" | "refresh" | "toJSON" | "toString" | "freshTimestamp" | "setRelation" | "getRelation" | "hasMany" | "belongsTo" | "hasOne" | "hasManyThrough" | "hasOneThrough" | "belongsToMany" | "morphTo" | "morphOne" | "morphMany" | "morphToMany" | "morphedByMany";
 export type ModelInstanceAttributeKeys<T> = Extract<Exclude<keyof T, BaseModelInstanceKey>, string>;
 export type ModelAttributes<T> = T extends {
     $attributes: Record<string, any>;
@@ -111,10 +111,9 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     $exists: boolean;
     $relations: Record<string, any>;
     $casts: Record<string, CastDefinition>;
+    $castCache: Record<string, any>;
     $connection?: Connection;
     constructor(attributes?: Partial<T>);
-    private defineAttributeProperty;
-    private syncAttributeProperties;
     static getTable(): string;
     static getConnection(): Connection;
     static setConnection(connection: Connection): void;
@@ -127,6 +126,7 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static applyGlobalScopes(builder: Builder<any>): void;
     static getQualifiedDeletedAtColumn(): string;
     static shouldAutoGeneratePrimaryKey(): Promise<boolean>;
+    static hydrate<M extends ModelConstructor>(this: M, row: Record<string, any>, connection?: Connection): InstanceType<M>;
     static create<M extends ModelConstructor>(this: M, attributes: ModelAttributeInput<InstanceType<M>>): Promise<InstanceType<M>>;
     static find<M extends ModelConstructor>(this: M, id: any): Promise<InstanceType<M> | null>;
     static findOrFail<M extends ModelConstructor>(this: M, id: any): Promise<InstanceType<M>>;

package/dist/src/model/Model.js

@@ -8,6 +8,44 @@ import { ModelNotFoundError } from "./ModelNotFoundError.js";
 import { ConnectionManager } from "../connection/ConnectionManager.js";
 import { TenantContext } from "../connection/TenantContext.js";
 import { IdentityMap } from "./IdentityMap.js";
+const modelProxyHandler = {
+    get(target, prop, receiver) {
+        if (typeof prop === "string" && !(prop in target) && prop in target.$attributes) {
+            return target.getAttribute(prop);
+        }
+        return Reflect.get(target, prop, receiver);
+    },
+    set(target, prop, value, receiver) {
+        if (typeof prop === "string" && !prop.startsWith("$") && !(prop in target)) {
+            target.setAttribute(prop, value);
+            return true;
+        }
+        return Reflect.set(target, prop, value, receiver);
+    },
+    has(target, prop) {
+        if (typeof prop === "string" && prop in target.$attributes)
+            return true;
+        return Reflect.has(target, prop);
+    },
+    getOwnPropertyDescriptor(target, prop) {
+        if (typeof prop === "string" && prop in target.$attributes) {
+            return {
+                enumerable: true,
+                configurable: true,
+                value: target.getAttribute(prop),
+            };
+        }
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+    },
+    ownKeys(target) {
+        const keys = new Set(Reflect.ownKeys(target));
+        for (const key of Object.keys(target.$attributes)) {
+            if (!key.startsWith("$"))
+                keys.add(key);
+        }
+        return Array.from(keys);
+    },
+};
 const globalScopes = new WeakMap();
 function getGlobalScopes(model) {
     const scopes = new Map();
@@ -306,6 +344,7 @@ export class Model {
     $exists = false;
     $relations = {};
     $casts = {};
+    $castCache = {};
     $connection;
     constructor(attributes) {
         const defaults = this.constructor.attributes;
@@ -315,72 +354,7 @@ export class Model {
         if (attributes) {
             this.fill(attributes);
         }
-        this.syncAttributeProperties();
-        // Minimal Proxy fallback for dynamic property access on undefined keys.
-        // Pre-defined attribute getters/setters bypass the Proxy entirely.
-        return new Proxy(this, {
-            get(target, prop, receiver) {
-                if (typeof prop === "string" && !(prop in target) && prop in target.$attributes) {
-                    return target.getAttribute(prop);
-                }
-                return Reflect.get(target, prop, receiver);
-            },
-            set(target, prop, value, receiver) {
-                if (typeof prop === "string" && !prop.startsWith("$") && !(prop in target)) {
-                    target.setAttribute(prop, value);
-                    return true;
-                }
-                return Reflect.set(target, prop, value, receiver);
-            },
-            has(target, prop) {
-                if (typeof prop === "string" && prop in target.$attributes)
-                    return true;
-                return Reflect.has(target, prop);
-            },
-            getOwnPropertyDescriptor(target, prop) {
-                if (typeof prop === "string" && prop in target.$attributes) {
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        value: target.getAttribute(prop),
-                    };
-                }
-                return Reflect.getOwnPropertyDescriptor(target, prop);
-            },
-            ownKeys(target) {
-                const keys = new Set(Reflect.ownKeys(target));
-                for (const key of Object.keys(target.$attributes)) {
-                    if (!key.startsWith("$"))
-                        keys.add(key);
-                }
-                return Array.from(keys);
-            },
-        });
-    }
-    defineAttributeProperty(key) {
-        if (key in this)
-            return;
-        Object.defineProperty(this, key, {
-            get: () => this.getAttribute(key),
-            set: (value) => this.setAttribute(key, value),
-            enumerable: true,
-            configurable: true,
-        });
-    }
-    syncAttributeProperties() {
-        const currentKeys = new Set(Object.keys(this.$attributes));
-        // Remove stale attribute properties
-        for (const key of Reflect.ownKeys(this)) {
-            if (key.startsWith("$") || typeof key !== "string")
-                continue;
-            const desc = Object.getOwnPropertyDescriptor(this, key);
-            if (desc && desc.get && desc.configurable && !currentKeys.has(key)) {
-                delete this[key];
-            }
-        }
-        for (const key of currentKeys) {
-            this.defineAttributeProperty(key);
-        }
+        return new Proxy(this, modelProxyHandler);
     }
     static getTable() {
         return this.table || snakeCase(this.name) + "s";
@@ -459,6 +433,17 @@ export class Model {
         const numericTypes = new Set(["integer", "int", "bigint", "smallint", "tinyint", "real", "float", "double", "decimal", "numeric"]);
         return !numericTypes.has(type);
     }
+    static hydrate(row, connection) {
+        const instance = new this();
+        instance.$attributes = { ...instance.$attributes, ...row };
+        instance.$original = { ...row };
+        instance.$castCache = {};
+        instance.$exists = true;
+        if (connection) {
+            instance.setConnection(connection);
+        }
+        return instance;
+    }
     static async create(attributes) {
         const instance = new this();
         instance.fill(attributes);
@@ -701,12 +686,19 @@ export class Model {
         return true;
     }
     getAttribute(key) {
+        if (Object.prototype.hasOwnProperty.call(this.$castCache, key)) {
+            return this.$castCache[key];
+        }
         const value = this.$attributes[key];
-        return this.castAttribute(key, value);
+        const casted = this.castAttribute(key, value);
+        if (this.getCastDefinition(key) && value !== null && value !== undefined) {
+            this.$castCache[key] = casted;
+        }
+        return casted;
     }
     setAttribute(key, value) {
         this.$attributes[key] = this.serializeCastAttribute(key, value);
-        this.defineAttributeProperty(key);
+        delete this.$castCache[key];
     }
     castAttribute(key, value) {
         const cast = this.getCastDefinition(key);
@@ -785,6 +777,7 @@ export class Model {
     }
     mergeCasts(casts) {
         this.$casts = { ...this.$casts, ...casts };
+        this.$castCache = {};
         return this;
     }
     getCastDefinition(key) {
@@ -819,6 +812,7 @@ export class Model {
             let dirty = this.getDirty();
             if (Object.keys(dirty).length > 0 && constructor.timestamps) {
                 this.$attributes["updated_at"] = this.freshTimestamp();
+                delete this.$castCache.updated_at;
                 dirty = this.getDirty();
             }
             if (Object.keys(dirty).length > 0) {
@@ -840,6 +834,8 @@ export class Model {
                 const now = this.freshTimestamp();
                 this.$attributes["created_at"] = now;
                 this.$attributes["updated_at"] = now;
+                delete this.$castCache.created_at;
+                delete this.$castCache.updated_at;
             }
             const primaryKey = constructor.primaryKey;
             const primaryKeyValue = this.getAttribute(primaryKey);
@@ -847,6 +843,7 @@ export class Model {
             if ((primaryKeyValue === null || primaryKeyValue === undefined || primaryKeyValue === "") && shouldGeneratePrimaryKey) {
                 const generated = crypto.randomUUID();
                 this.$attributes[primaryKey] = generated;
+                delete this.$castCache[primaryKey];
             }
             const connection = this.getConnection();
             if (shouldGeneratePrimaryKey || primaryKeyValue !== null && primaryKeyValue !== undefined && primaryKeyValue !== "") {
@@ -856,6 +853,7 @@ export class Model {
                 const result = await new Builder(connection, connection.qualifyTable(constructor.getTable())).insertGetId(this.$attributes);
                 if (result) {
                     this.$attributes[constructor.primaryKey] = result;
+                    delete this.$castCache[constructor.primaryKey];
                 }
             }
             this.$exists = true;
@@ -863,7 +861,6 @@ export class Model {
             await ObserverRegistry.dispatch("created", this);
             await ObserverRegistry.dispatch("saved", this);
         }
-        this.syncAttributeProperties();
         const identityMap = IdentityMap.current();
         if (identityMap) {
             const pk = this.getAttribute(constructor.primaryKey);
@@ -879,10 +876,11 @@ export class Model {
             return;
         const now = this.freshTimestamp();
         this.$attributes["updated_at"] = now;
+        delete this.$castCache.updated_at;
         if (!this.$exists) {
             this.$attributes["created_at"] = now;
+            delete this.$castCache.created_at;
         }
-        this.syncAttributeProperties();
     }
     async touch() {
         if (!this.$exists)
@@ -897,8 +895,8 @@ export class Model {
             .where(constructor.primaryKey, pk)
             .update({ updated_at: now });
         this.$attributes["updated_at"] = now;
+        delete this.$castCache.updated_at;
         this.$original = { ...this.$attributes };
-        this.syncAttributeProperties();
         return true;
     }
     async increment(column, amount = 1, extra = {}) {
@@ -914,11 +912,12 @@ export class Model {
         }
         await builder.increment(column, amount, extra);
         this.$attributes[column] = (this.$attributes[column] || 0) + amount;
+        delete this.$castCache[column];
         for (const [key, value] of Object.entries(extra)) {
             this.$attributes[key] = value;
+            delete this.$castCache[key];
         }
         this.$original = { ...this.$attributes };
-        this.syncAttributeProperties();
         return this;
     }
     async decrement(column, amount = 1, extra = {}) {
@@ -942,8 +941,8 @@ export class Model {
                 .where(constructor.primaryKey, pk)
                 .update({ [constructor.deletedAtColumn]: deletedAt });
             this.$attributes[constructor.deletedAtColumn] = deletedAt;
+            delete this.$castCache[constructor.deletedAtColumn];
             this.$original = { ...this.$attributes };
-            this.syncAttributeProperties();
         }
         else {
             const connection = this.getConnection();
@@ -971,9 +970,9 @@ export class Model {
             .where(constructor.primaryKey, pk)
             .update({ [constructor.deletedAtColumn]: null });
         this.$attributes[constructor.deletedAtColumn] = null;
+        delete this.$castCache[constructor.deletedAtColumn];
         this.$original = { ...this.$attributes };
         this.$exists = true;
-        this.syncAttributeProperties();
         return true;
     }
     async forceDelete() {
@@ -1006,7 +1005,7 @@ export class Model {
         if (result) {
             this.$attributes = result.$attributes;
             this.$original = { ...result.$attributes };
-            this.syncAttributeProperties();
+            this.$castCache = {};
             // Ensure this instance is the canonical one in the identity map
             if (identityMap) {
                 IdentityMap.set(constructor.getTable(), pk, this);

package/dist/src/query/Builder.d.ts

@@ -32,8 +32,10 @@ export declare class Builder<T = Record<string, any>> {
     updateJoins: string[];
     bindings: any[];
     private parameterize;
+    private sqlCache?;
     constructor(connection: Connection, table: string);
     private get grammar();
+    private invalidateSqlCache;
     setModel(model: ModelConstructor): this;
     table(table: string): this;
     select(...columns: ModelColumn<T>[]): this;

package/dist/src/query/Builder.js

@@ -21,6 +21,7 @@ export class Builder {
     updateJoins = [];
     bindings = [];
     parameterize = false;
+    sqlCache;
     constructor(connection, table) {
         this.connection = connection;
         this.tableName = table;
@@ -28,19 +29,25 @@ export class Builder {
     get grammar() {
         return this.connection.getGrammar();
     }
+    invalidateSqlCache() {
+        this.sqlCache = undefined;
+    }
     setModel(model) {
         this.model = model;
         return this;
     }
     table(table) {
+        this.invalidateSqlCache();
         this.tableName = table;
         return this;
     }
     select(...columns) {
+        this.invalidateSqlCache();
         this.columns = columns;
         return this;
     }
     distinct() {
+        this.invalidateSqlCache();
         this.distinctFlag = true;
         return this;
     }
@@ -58,6 +65,7 @@ export class Builder {
             value = operator;
             operator = "=";
         }
+        this.invalidateSqlCache();
         this.wheres.push({ type: "basic", column, operator, value, boolean, scope });
         return this;
     }
@@ -65,6 +73,7 @@ export class Builder {
         const nested = new Builder(this.connection, this.tableName);
         callback(nested);
         if (nested.wheres.length > 0) {
+            this.invalidateSqlCache();
             this.wheres.push({ type: "nested", column: "", query: nested.wheres, boolean, scope: undefined });
         }
         return this;
@@ -85,26 +94,32 @@ export class Builder {
         return this.whereNot(column, value, "or");
     }
     whereIn(column, values, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "in", column, value: values, boolean, scope });
         return this;
     }
     whereNotIn(column, values, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "in", column, value: values, boolean, operator: "NOT IN", scope });
         return this;
     }
     whereNull(column, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "null", column, boolean, scope });
         return this;
     }
     whereNotNull(column, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "null", column, boolean, operator: "NOT NULL", scope });
         return this;
     }
     whereBetween(column, values, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "between", column, value: values, boolean, scope });
         return this;
     }
     whereNotBetween(column, values, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "between", column, value: values, boolean, operator: "NOT BETWEEN", scope });
         return this;
     }
@@ -139,14 +154,17 @@ export class Builder {
         return this.whereTime(column, operator, value, "or");
     }
     whereRaw(sql, boolean = "and", scope) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "raw", column: sql, boolean, scope });
         return this;
     }
     whereColumn(first, operator, second, boolean = "and") {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "column", column: first, operator, value: second, boolean });
         return this;
     }
     whereExists(sql, boolean = "and", not = false) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "exists", column: sql, boolean, operator: not ? "NOT EXISTS" : "EXISTS" });
         return this;
     }
@@ -181,6 +199,7 @@ export class Builder {
         return this.whereRaw(sql, "or", scope);
     }
     whereJsonContains(column, value, boolean = "and", not = false) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "json_contains", column, value, boolean, scope: undefined, not });
         return this;
     }
@@ -189,10 +208,12 @@ export class Builder {
             value = operator;
             operator = "=";
         }
+        this.invalidateSqlCache();
         this.wheres.push({ type: "json_length", column, operator: String(operator), value, boolean, scope: undefined, not });
         return this;
     }
     whereLike(column, value, boolean = "and", not = false) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "like", column, value, boolean, scope: undefined, not });
         return this;
     }
@@ -200,23 +221,28 @@ export class Builder {
         return this.whereLike(column, value, "and", true);
     }
     whereRegexp(column, value, boolean = "and", not = false) {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "regexp", column, value, boolean, scope: undefined, not });
         return this;
     }
     whereFullText(columns, value, boolean = "and", not = false) {
         const cols = Array.isArray(columns) ? columns : [columns];
+        this.invalidateSqlCache();
         this.wheres.push({ type: "fulltext", column: "", columns: cols, value, boolean, scope: undefined, not });
         return this;
     }
     whereAll(columns, operator, value, boolean = "and") {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "all", column: "", columns: columns, operator, value, boolean, scope: undefined });
         return this;
     }
     whereAny(columns, operator, value, boolean = "and") {
+        this.invalidateSqlCache();
         this.wheres.push({ type: "any", column: "", columns: columns, operator, value, boolean, scope: undefined });
         return this;
     }
     orderBy(column, direction = "asc") {
+        this.invalidateSqlCache();
         this.orders.push({ column, direction });
         return this;
     }
@@ -227,6 +253,7 @@ export class Builder {
         return this.orderBy(column, "asc");
     }
     inRandomOrder() {
+        this.invalidateSqlCache();
         this.randomOrderFlag = true;
         return this;
     }
@@ -234,6 +261,7 @@ export class Builder {
         return this.orderBy(column, "desc");
     }
     reorder(column, direction = "asc") {
+        this.invalidateSqlCache();
         this.orders = [];
         this.randomOrderFlag = false;
         if (column) {
@@ -242,18 +270,22 @@ export class Builder {
         return this;
     }
     groupBy(...columns) {
+        this.invalidateSqlCache();
         this.groups.push(...columns);
         return this;
     }
     having(column, operator, value) {
+        this.invalidateSqlCache();
         this.havings.push({ column, operator, value, boolean: "and" });
         return this;
     }
     orHaving(column, operator, value) {
+        this.invalidateSqlCache();
         this.havings.push({ column, operator, value, boolean: "or" });
         return this;
     }
     havingRaw(sql, boolean = "and") {
+        this.invalidateSqlCache();
         this.havings.push({ sql, boolean });
         return this;
     }
@@ -261,10 +293,12 @@ export class Builder {
         return this.havingRaw(sql, "or");
     }
     limit(count) {
+        this.invalidateSqlCache();
         this.limitValue = count;
         return this;
     }
     offset(count) {
+        this.invalidateSqlCache();
         this.offsetValue = count;
         return this;
     }
@@ -273,6 +307,7 @@ export class Builder {
     }
     join(table, first, operator, second, type = "INNER") {
         const joinSql = `${type} JOIN ${this.grammar.wrap(table)} ON ${this.grammar.wrap(first)} ${operator} ${this.grammar.wrap(second)}`;
+        this.invalidateSqlCache();
         this.joins.push(joinSql);
         return this;
     }
@@ -283,11 +318,13 @@ export class Builder {
         return this.join(table, first, operator, second, "RIGHT");
     }
     crossJoin(table) {
+        this.invalidateSqlCache();
         this.joins.push(`CROSS JOIN ${this.grammar.wrap(table)}`);
         return this;
     }
     union(query, all = false) {
         const sql = typeof query === "string" ? query : query.toSql();
+        this.invalidateSqlCache();
         this.unions.push({ query: sql, all });
         return this;
     }
@@ -299,10 +336,12 @@ export class Builder {
         return this;
     }
     withoutGlobalScope(scope) {
+        this.invalidateSqlCache();
         this.wheres = this.wheres.filter((where) => where.scope !== scope);
         return this;
     }
     withoutGlobalScopes() {
+        this.invalidateSqlCache();
         this.wheres = this.wheres.filter((where) => !where.scope);
         return this;
     }
@@ -407,6 +446,7 @@ export class Builder {
         return this.withAggregate(relationName, column, "MAX", alias);
     }
     addSelect(...columns) {
+        this.invalidateSqlCache();
         if (this.columns.length === 1 && this.columns[0] === "*") {
             this.columns = [`${this.tableName}.*`];
         }
@@ -414,15 +454,18 @@ export class Builder {
         return this;
     }
     selectRaw(sql) {
+        this.invalidateSqlCache();
         this.columns.push(sql);
         return this;
     }
     fromSub(query, as) {
         const sql = typeof query === "string" ? query : query.toSql();
+        this.invalidateSqlCache();
         this.fromRaw = `(${sql}) AS ${this.grammar.wrap(as)}`;
         return this;
     }
     updateFrom(table, first, operator, second) {
+        this.invalidateSqlCache();
         this.updateJoins.push(`INNER JOIN ${this.grammar.wrap(table)} ON ${this.grammar.wrap(first)} ${operator} ${this.grammar.wrap(second)}`);
         return this;
     }
@@ -598,6 +641,8 @@ export class Builder {
         return column.includes("(") || /\s+as\s+/i.test(column) || /^[0-9]+$/.test(column);
     }
     toSql() {
+        if (!this.parameterize && this.sqlCache)
+            return this.sqlCache;
         const distinct = this.distinctFlag ? "DISTINCT " : "";
         const from = this.fromRaw || this.grammar.wrap(this.tableName);
         let sql = `SELECT ${distinct}${this.compileColumns()} FROM ${from}`;
@@ -613,7 +658,10 @@ export class Builder {
         for (const union of this.unions) {
             sql += ` UNION${union.all ? " ALL" : ""} ${union.query}`;
         }
-        return sql.replace(/\s+/g, " ").trim();
+        const compiled = sql.replace(/\s+/g, " ").trim();
+        if (!this.parameterize)
+            this.sqlCache = compiled;
+        return compiled;
     }
     async get() {
         this.bindings = [];
@@ -636,12 +684,7 @@ export class Builder {
                         }
                     }
                 }
-                const instance = new this.model(row);
-                instance.$exists = true;
-                instance.$original = { ...row };
-                if (typeof instance.setConnection === "function") {
-                    instance.setConnection(this.connection);
-                }
+                const instance = this.model.hydrate(row, this.connection);
                 if (identityMap) {
                     const pk = row[primaryKey];
                     if (pk !== null && pk !== undefined) {
@@ -725,6 +768,7 @@ export class Builder {
         query.offsetValue = undefined;
         query.eagerLoads = [];
         query.lockMode = undefined;
+        query.invalidateSqlCache();
         const result = await query.first();
         return result ? result[alias] : null;
     }
@@ -748,6 +792,7 @@ export class Builder {
         countQuery.limitValue = undefined;
         countQuery.offsetValue = undefined;
         countQuery.orders = [];
+        countQuery.invalidateSqlCache();
         const total = await countQuery.count();
         const data = await this.clone().forPage(page, perPage).get();
         return {
@@ -1023,6 +1068,7 @@ export class Builder {
     lockForUpdate() {
         const driver = this.connection.getDriverName();
         if (driver !== "sqlite") {
+            this.invalidateSqlCache();
             this.lockMode = "FOR UPDATE";
         }
         return this;
@@ -1030,21 +1076,25 @@ export class Builder {
     sharedLock() {
         const driver = this.connection.getDriverName();
         if (driver === "mysql") {
+            this.invalidateSqlCache();
             this.lockMode = "LOCK IN SHARE MODE";
         }
         else if (driver === "postgres") {
+            this.invalidateSqlCache();
             this.lockMode = "FOR SHARE";
         }
         return this;
     }
     skipLocked() {
         if (this.lockMode) {
+            this.invalidateSqlCache();
             this.lockMode += " SKIP LOCKED";
         }
         return this;
     }
     noWait() {
         if (this.lockMode) {
+            this.invalidateSqlCache();
             this.lockMode += " NOWAIT";
         }
         return this;
@@ -1054,6 +1104,7 @@ export class Builder {
             value = operator;
             operator = "=";
         }
+        this.invalidateSqlCache();
         this.wheres.push({ type: "date", column: column, operator, value, boolean, scope: undefined, dateType: type });
         return this;
     }

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.23",
+  "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",