@bunnykit/orm 0.1.18 → 0.1.20

package/dist/src/index.d.ts

@@ -20,6 +20,7 @@ export { ObserverRegistry, type ObserverContract } from "./model/Observer.js";
 export { MorphMap } from "./model/MorphMap.js";
 export { MorphTo, MorphOne, MorphMany, MorphToMany } from "./model/MorphRelations.js";
 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";

package/dist/src/index.js

@@ -15,6 +15,7 @@ export { ObserverRegistry } from "./model/Observer.js";
 export { MorphMap } from "./model/MorphMap.js";
 export { MorphTo, MorphOne, MorphMany, MorphToMany } from "./model/MorphRelations.js";
 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 { MigrationCreator } from "./migration/MigrationCreator.js";

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

@@ -0,0 +1,8 @@
+import type { Model } from "./Model.js";
+export declare class IdentityMap {
+    static current(): Map<string, Model> | undefined;
+    static run<T>(callback: () => T | Promise<T>): Promise<T>;
+    static get(table: string, key: string | number): Model | undefined;
+    static set(table: string, key: string | number, model: Model): void;
+    static clear(): void;
+}

package/dist/src/model/IdentityMap.js

@@ -0,0 +1,28 @@
+import { AsyncLocalStorage } from "node:async_hooks";
+const storage = new AsyncLocalStorage();
+export class IdentityMap {
+    static current() {
+        return storage.getStore();
+    }
+    static async run(callback) {
+        return await storage.run(new Map(), callback);
+    }
+    static get(table, key) {
+        const map = this.current();
+        if (!map)
+            return undefined;
+        return map.get(`${table}:${String(key)}`);
+    }
+    static set(table, key, model) {
+        const map = this.current();
+        if (!map)
+            return;
+        map.set(`${table}:${String(key)}`, model);
+    }
+    static clear() {
+        const map = this.current();
+        if (!map)
+            return;
+        map.clear();
+    }
+}

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

@@ -105,6 +105,7 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     static attributes: Record<string, any>;
     static softDeletes: boolean;
     static deletedAtColumn: string;
+    static preventLazyLoading: boolean;
     $attributes: T;
     $original: Partial<T>;
     $exists: boolean;
@@ -112,9 +113,12 @@ export declare class Model<T extends Record<string, any> = Record<string, any>>
     $casts: Record<string, CastDefinition>;
     $connection?: Connection;
     constructor(attributes?: Partial<T>);
+    private defineAttributeProperty;
+    private syncAttributeProperties;
     static getTable(): string;
     static getConnection(): Connection;
     static setConnection(connection: Connection): void;
+    static useIdentityMap<T>(callback: () => T | Promise<T>): Promise<T>;
     static on<M extends ModelConstructor>(this: M, connection: string | Connection): Builder<InstanceType<M>>;
     static forTenant<M extends ModelConstructor>(this: M, tenantId: string): Builder<InstanceType<M>>;
     static query<M extends ModelConstructor>(this: M): Builder<InstanceType<M>>;

package/dist/src/model/Model.js

@@ -7,6 +7,7 @@ import { Schema } from "../schema/Schema.js";
 import { ModelNotFoundError } from "./ModelNotFoundError.js";
 import { ConnectionManager } from "../connection/ConnectionManager.js";
 import { TenantContext } from "../connection/TenantContext.js";
+import { IdentityMap } from "./IdentityMap.js";
 const globalScopes = new WeakMap();
 function getGlobalScopes(model) {
     const scopes = new Map();
@@ -37,6 +38,15 @@ export class Relation {
         this.builder = related.on(parent.getConnection());
         this.foreignKey = foreignKey || this.defaultForeignKey();
         this.localKey = localKey || related.primaryKey;
+        // Wrap getResults with lazy-loading guard
+        const originalGetResults = this.getResults.bind(this);
+        this.getResults = async () => {
+            if (this.parent.constructor.preventLazyLoading) {
+                throw new Error(`Lazy loading is prevented on ${this.parent.constructor.name}. ` +
+                    `Eager load the relation using with().`);
+            }
+            return await originalGetResults();
+        };
     }
     defaultForeignKey() {
         return `${snakeCase(this.parent.constructor.name)}_id`;
@@ -290,6 +300,7 @@ export class Model {
     static attributes = {};
     static softDeletes = false;
     static deletedAtColumn = "deleted_at";
+    static preventLazyLoading = false;
     $attributes = {};
     $original = {};
     $exists = false;
@@ -304,6 +315,9 @@ 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) {
@@ -318,25 +332,23 @@ export class Model {
                 }
                 return Reflect.set(target, prop, value, receiver);
             },
-            has(target, prop) {
-                return prop in target || (typeof prop === "string" && prop in target.$attributes);
-            },
-            getOwnPropertyDescriptor(target, prop) {
-                if (typeof prop === "string" && !(prop in target) && prop in target.$attributes) {
-                    return {
-                        enumerable: true,
-                        configurable: true,
-                        writable: true,
-                        value: target.getAttribute(prop),
-                    };
-                }
-                return Reflect.getOwnPropertyDescriptor(target, prop);
-            },
-            ownKeys(target) {
-                return [...new Set([...Reflect.ownKeys(target), ...Object.keys(target.$attributes)])];
-            },
         });
     }
+    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() {
+        for (const key of Object.keys(this.$attributes)) {
+            this.defineAttributeProperty(key);
+        }
+    }
     static getTable() {
         return this.table || snakeCase(this.name) + "s";
     }
@@ -353,6 +365,9 @@ export class Model {
         this.connection = connection;
         ConnectionManager.setDefault(connection);
     }
+    static useIdentityMap(callback) {
+        return IdentityMap.run(callback);
+    }
     static on(connection) {
         const resolved = typeof connection === "string" ? ConnectionManager.require(connection) : connection;
         const builder = new Builder(resolved, resolved.qualifyTable(this.getTable()));
@@ -658,6 +673,7 @@ export class Model {
     }
     setAttribute(key, value) {
         this.$attributes[key] = this.serializeCastAttribute(key, value);
+        this.defineAttributeProperty(key);
     }
     castAttribute(key, value) {
         const cast = this.getCastDefinition(key);
@@ -813,6 +829,14 @@ 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);
+            if (pk !== null && pk !== undefined && pk !== "") {
+                IdentityMap.set(constructor.getTable(), pk, this);
+            }
+        }
         return this;
     }
     updateTimestamps() {
@@ -824,6 +848,7 @@ export class Model {
         if (!this.$exists) {
             this.$attributes["created_at"] = now;
         }
+        this.syncAttributeProperties();
     }
     async touch() {
         if (!this.$exists)
@@ -839,6 +864,7 @@ export class Model {
             .update({ updated_at: now });
         this.$attributes["updated_at"] = now;
         this.$original = { ...this.$attributes };
+        this.syncAttributeProperties();
         return true;
     }
     async increment(column, amount = 1, extra = {}) {
@@ -858,6 +884,7 @@ export class Model {
             this.$attributes[key] = value;
         }
         this.$original = { ...this.$attributes };
+        this.syncAttributeProperties();
         return this;
     }
     async decrement(column, amount = 1, extra = {}) {
@@ -882,6 +909,7 @@ export class Model {
                 .update({ [constructor.deletedAtColumn]: deletedAt });
             this.$attributes[constructor.deletedAtColumn] = deletedAt;
             this.$original = { ...this.$attributes };
+            this.syncAttributeProperties();
         }
         else {
             const connection = this.getConnection();
@@ -907,6 +935,7 @@ export class Model {
         this.$attributes[constructor.deletedAtColumn] = null;
         this.$original = { ...this.$attributes };
         this.$exists = true;
+        this.syncAttributeProperties();
         return true;
     }
     async forceDelete() {
@@ -930,6 +959,7 @@ export class Model {
         if (result) {
             this.$attributes = result.$attributes;
             this.$original = { ...result.$attributes };
+            this.syncAttributeProperties();
         }
         return this;
     }

package/dist/src/query/Builder.js

@@ -1,4 +1,5 @@
 import { ModelNotFoundError } from "../model/ModelNotFoundError.js";
+import { IdentityMap } from "../model/IdentityMap.js";
 export class Builder {
     connection;
     tableName;
@@ -589,13 +590,31 @@ export class Builder {
         const results = await this.connection.query(sql, this.bindings);
         const rows = Array.from(results);
         if (this.model) {
+            const identityMap = IdentityMap.current();
+            const table = this.model.getTable();
+            const primaryKey = this.model.primaryKey || "id";
             const models = rows.map((row) => {
+                if (identityMap) {
+                    const pk = row[primaryKey];
+                    if (pk !== null && pk !== undefined) {
+                        const cached = IdentityMap.get(table, pk);
+                        if (cached) {
+                            return cached;
+                        }
+                    }
+                }
                 const instance = new this.model(row);
                 instance.$exists = true;
                 instance.$original = { ...row };
                 if (typeof instance.setConnection === "function") {
                     instance.setConnection(this.connection);
                 }
+                if (identityMap) {
+                    const pk = row[primaryKey];
+                    if (pk !== null && pk !== undefined) {
+                        IdentityMap.set(table, pk, instance);
+                    }
+                }
                 return instance;
             });
             if (this.eagerLoads.length > 0) {

package/package.json

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