metal-orm 1.0.105 → 1.0.107

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "metal-orm",
-  "version": "1.0.105",
+  "version": "1.0.107",
   "type": "module",
   "types": "./dist/index.d.ts",
   "engines": {

package/src/orm/entity-relations.ts

@@ -17,36 +17,13 @@ export type RelationEntityFactory = (
 
 const proxifyRelationWrapper = <T extends object>(wrapper: T): T => {
   return new Proxy(wrapper, {
-    get(target, prop, _receiver) {
-      // Intercept toJSON to ensure proper serialization
-      if (prop === 'toJSON') {
-        return () => {
-          // Call the wrapper's toJSON method if it exists
-          const wrapperToJSON = (target as { toJSON?: () => unknown }).toJSON;
-          if (typeof wrapperToJSON === 'function') {
-            return wrapperToJSON.call(target);
-          }
-          // Fallback: return the underlying data
-          const getRef = (target as { get?: () => unknown }).get;
-          if (typeof getRef === 'function') {
-            return getRef.call(target);
-          }
-          const getItems = (target as { getItems?: () => unknown }).getItems;
-          if (typeof getItems === 'function') {
-            return getItems.call(target);
-          }
-          return target;
-        };
-      }
-
+    get(target, prop, receiver) {
       if (typeof prop === 'symbol') {
-        const value = Reflect.get(target, prop, target);
-        return typeof value === 'function' ? value.bind(target) : value;
+        return Reflect.get(target, prop, receiver);
       }
 
       if (prop in target) {
-        const value = Reflect.get(target, prop, target);
-        return typeof value === 'function' ? value.bind(target) : value;
+        return Reflect.get(target, prop, receiver);
       }
 
       const getItems = (target as { getItems?: () => unknown }).getItems;
@@ -72,13 +49,13 @@ const proxifyRelationWrapper = <T extends object>(wrapper: T): T => {
       return undefined;
     },
 
-    set(target, prop, value, _receiver) {
+    set(target, prop, value, receiver) {
       if (typeof prop === 'symbol') {
-        return Reflect.set(target, prop, value, target);
+        return Reflect.set(target, prop, value, receiver);
       }
 
       if (prop in target) {
-        return Reflect.set(target, prop, value, target);
+        return Reflect.set(target, prop, value, receiver);
       }
 
       const getRef = (target as { get?: () => unknown }).get;
@@ -95,7 +72,7 @@ const proxifyRelationWrapper = <T extends object>(wrapper: T): T => {
         return Reflect.set(items as object, prop, value);
       }
 
-      return Reflect.set(target, prop, value, target);
+      return Reflect.set(target, prop, value, receiver);
     }
   });
 };

package/src/orm/entity.ts

@@ -11,16 +11,7 @@ export { relationLoaderCache } from './entity-relation-cache.js';
 
 const isRelationWrapperLoaded = (value: unknown): boolean => {
   if (!value || typeof value !== 'object') return false;
-  const wrapper = value as { isLoaded?: () => boolean };
-  if (typeof wrapper.isLoaded === 'function') return wrapper.isLoaded();
-  return false;
-};
-
-const unwrapRelationForJson = (value: unknown): unknown => {
-  if (value && typeof value === 'object' && typeof (value as { toJSON?: () => unknown }).toJSON === 'function') {
-    return (value as { toJSON: () => unknown }).toJSON();
-  }
-  return value;
+  return Boolean((value as { loaded?: boolean }).loaded);
 };
 
 type JsonSource<TTable extends TableDef> = EntityInstance<TTable> & Record<string, unknown>;
@@ -61,14 +52,16 @@ export const createEntityProxy = <
   const buildJson = (self: JsonSource<TTable>): Record<string, unknown> => {
     const json: Record<string, unknown> = {};
     for (const key of Object.keys(target)) {
-      const value = self[key];
-      // Unwrap relation wrappers to get the actual data
-      json[key] = unwrapRelationForJson(value);
+      if (table.relations[key]) continue;
+      json[key] = self[key];
     }
-    for (const [relationName, wrapper] of meta.relationWrappers) {
-      if (Object.prototype.hasOwnProperty.call(json, relationName)) continue;
-      if (isRelationWrapperLoaded(wrapper)) {
-        json[relationName] = unwrapRelationForJson(wrapper);
+    for (const relationName of Object.keys(table.relations)) {
+      const wrapper = self[relationName];
+      if (wrapper && isRelationWrapperLoaded(wrapper)) {
+        const wrapperWithToJSON = wrapper as { toJSON?: () => unknown };
+        json[relationName] = typeof wrapperWithToJSON.toJSON === 'function'
+          ? wrapperWithToJSON.toJSON()
+          : wrapper;
       }
     }
     return json;

package/src/orm/relations/belongs-to.ts

@@ -14,7 +14,19 @@ const hideInternal = (obj: object, keys: string[]): void => {
     Object.defineProperty(obj, key, {
       value: obj[key],
       writable: false,
-      configurable: true,  // Must be configurable for Proxy get trap to work properly
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+
+const hideWritable = (obj: object, keys: string[]): void => {
+  for (const key of keys) {
+    const value = obj[key as keyof typeof obj];
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      configurable: true,
       enumerable: false
     });
   }
@@ -27,8 +39,8 @@ const hideInternal = (obj: object, keys: string[]): void => {
  * @template TParent The type of the parent entity.
  */
 export class DefaultBelongsToReference<TParent extends object> implements BelongsToReferenceApi<TParent> {
-  #loaded = false;
-  #current: TParent | null = null;
+  private loaded = false;
+  private current: TParent | null = null;
 
   /**
    * @param ctx The entity context for tracking changes.
@@ -53,32 +65,33 @@ export class DefaultBelongsToReference<TParent extends object> implements Belong
     private readonly targetKey: string
   ) {
     hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'targetKey']);
+    hideWritable(this, ['loaded', 'current']);
     this.populateFromHydrationCache();
   }
 
   async load(): Promise<TParent | null> {
-    if (this.#loaded) return this.#current;
+    if (this.loaded) return this.current;
     const map = await this.loader();
     const fkValue = (this.root as Record<string, unknown>)[this.relation.foreignKey];
     if (fkValue === null || fkValue === undefined) {
-      this.#current = null;
+      this.current = null;
     } else {
       const row = map.get(toKey(fkValue));
-      this.#current = row ? this.createEntity(row) : null;
+      this.current = row ? this.createEntity(row) : null;
     }
-    this.#loaded = true;
-    return this.#current;
+    this.loaded = true;
+    return this.current;
   }
 
   get(): TParent | null {
-    return this.#current;
+    return this.current;
   }
 
   set(data: Partial<TParent> | TParent | null): TParent | null {
     if (data === null) {
-      const previous = this.#current;
+      const previous = this.current;
       (this.root as Record<string, unknown>)[this.relation.foreignKey] = null;
-      this.#current = null;
+      this.current = null;
       this.ctx.registerRelationChange(
         this.root,
         this.relationKey,
@@ -95,7 +108,7 @@ export class DefaultBelongsToReference<TParent extends object> implements Belong
     if (pkValue !== undefined) {
       (this.root as Record<string, unknown>)[this.relation.foreignKey] = pkValue;
     }
-    this.#current = entity;
+    this.current = entity;
     this.ctx.registerRelationChange(
       this.root,
       this.relationKey,
@@ -107,10 +120,6 @@ export class DefaultBelongsToReference<TParent extends object> implements Belong
     return entity;
   }
 
-  isLoaded(): boolean {
-    return this.#loaded;
-  }
-
   private get relationKey(): RelationKey {
     return `${this.rootTable.name}.${this.relationName}`;
   }
@@ -120,11 +129,11 @@ export class DefaultBelongsToReference<TParent extends object> implements Belong
     if (fkValue === undefined || fkValue === null) return;
     const row = getHydrationRecord(this.meta, this.relationName, fkValue);
     if (!row) return;
-    this.#current = this.createEntity(row);
-    this.#loaded = true;
+    this.current = this.createEntity(row);
+    this.loaded = true;
   }
 
   toJSON(): TParent | null {
-    return this.#current;
+    return this.current;
   }
 }

package/src/orm/relations/has-many.ts

@@ -14,7 +14,19 @@ const hideInternal = (obj: object, keys: string[]): void => {
     Object.defineProperty(obj, key, {
       value: obj[key],
       writable: false,
-      configurable: true,  // Must be configurable for Proxy get trap to work properly
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+
+const hideWritable = (obj: object, keys: string[]): void => {
+  for (const key of keys) {
+    const value = obj[key as keyof typeof obj];
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      configurable: true,
       enumerable: false
     });
   }
@@ -25,10 +37,10 @@ const hideInternal = (obj: object, keys: string[]): void => {
  * @template TChild - The type of child entities in the collection
  */
 export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChild> {
-  #loaded = false;
-  #items: TChild[] = [];
-  readonly #added = new Set<TChild>();
-  readonly #removed = new Set<TChild>();
+  private loaded = false;
+  private items: TChild[] = [];
+  private readonly added = new Set<TChild>();
+  private readonly removed = new Set<TChild>();
 
   /**
    * Creates a new DefaultHasManyCollection instance.
@@ -54,6 +66,7 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
     private readonly localKey: string
   ) {
     hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'localKey']);
+    hideWritable(this, ['loaded', 'items', 'added', 'removed']);
     this.hydrateFromCache();
   }
 
@@ -62,13 +75,13 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
    * @returns Promise resolving to the array of child entities
    */
   async load(): Promise<TChild[]> {
-    if (this.#loaded) return this.#items;
+    if (this.loaded) return this.items;
     const map = await this.loader();
     const key = toKey((this.root as Record<string, unknown>)[this.localKey]);
     const rows = map.get(key) ?? [];
-    this.#items = rows.map(row => this.createEntity(row));
-    this.#loaded = true;
-    return this.#items;
+    this.items = rows.map(row => this.createEntity(row));
+    this.loaded = true;
+    return this.items;
   }
 
   /**
@@ -76,21 +89,21 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
    * @returns Array of child entities
    */
   getItems(): TChild[] {
-    return this.#items;
+    return this.items;
   }
-
+ 
   /**
    * Array-compatible length for testing frameworks.
    */
   get length(): number {
-    return this.#items.length;
+    return this.items.length;
   }
 
   /**
    * Enables iteration over the collection like an array.
    */
   [Symbol.iterator](): Iterator<TChild> {
-    return this.#items[Symbol.iterator]();
+    return this.items[Symbol.iterator]();
   }
 
   /**
@@ -105,8 +118,8 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
       [this.relation.foreignKey]: keyValue
     };
     const entity = this.createEntity(childRow);
-    this.#added.add(entity);
-    this.#items.push(entity);
+    this.added.add(entity);
+    this.items.push(entity);
     this.ctx.registerRelationChange(
       this.root,
       this.relationKey,
@@ -126,7 +139,7 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
     const keyValue = this.root[this.localKey];
     (entity as Record<string, unknown>)[this.relation.foreignKey] = keyValue;
     this.ctx.markDirty(entity as object);
-    this.#items.push(entity);
+    this.items.push(entity);
     this.ctx.registerRelationChange(
       this.root,
       this.relationKey,
@@ -142,8 +155,8 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
    * @param entity - The entity to remove
    */
   remove(entity: TChild): void {
-    this.#items = this.#items.filter(item => item !== entity);
-    this.#removed.add(entity);
+    this.items = this.items.filter(item => item !== entity);
+    this.removed.add(entity);
     this.ctx.registerRelationChange(
       this.root,
       this.relationKey,
@@ -158,15 +171,11 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
    * Clears all entities from the collection.
    */
   clear(): void {
-    for (const entity of [...this.#items]) {
+    for (const entity of [...this.items]) {
       this.remove(entity);
     }
   }
 
-  isLoaded(): boolean {
-    return this.#loaded;
-  }
-
   private get relationKey(): RelationKey {
     return `${this.rootTable.name}.${this.relationName}`;
   }
@@ -176,8 +185,8 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
     if (keyValue === undefined || keyValue === null) return;
     const rows = getHydrationRows(this.meta, this.relationName, keyValue);
     if (!rows?.length) return;
-    this.#items = rows.map(row => this.createEntity(row));
-    this.#loaded = true;
+    this.items = rows.map(row => this.createEntity(row));
+    this.loaded = true;
   }
 
   /**
@@ -185,6 +194,6 @@ export class DefaultHasManyCollection<TChild> implements HasManyCollection<TChil
    * @returns Array of child entities
    */
   toJSON(): TChild[] {
-    return this.#items;
+    return this.items;
   }
 }

package/src/orm/relations/has-one.ts

@@ -14,7 +14,19 @@ const hideInternal = (obj: object, keys: string[]): void => {
     Object.defineProperty(obj, key, {
       value: obj[key],
       writable: false,
-      configurable: true,  // Must be configurable for Proxy get trap to work properly
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+
+const hideWritable = (obj: object, keys: string[]): void => {
+  for (const key of keys) {
+    const value = obj[key as keyof typeof obj];
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      configurable: true,
       enumerable: false
     });
   }
@@ -27,8 +39,8 @@ const hideInternal = (obj: object, keys: string[]): void => {
  * @template TChild The type of the child entity.
  */
 export class DefaultHasOneReference<TChild extends object> implements HasOneReferenceApi<TChild> {
-  #loaded = false;
-  #current: TChild | null = null;
+  private loaded = false;
+  private current: TChild | null = null;
 
   /**
    * @param ctx The entity context for tracking changes.
@@ -63,25 +75,26 @@ export class DefaultHasOneReference<TChild extends object> implements HasOneRefe
       'createEntity',
       'localKey'
     ]);
+    hideWritable(this, ['loaded', 'current']);
     this.populateFromHydrationCache();
   }
 
   async load(): Promise<TChild | null> {
-    if (this.#loaded) return this.#current;
+    if (this.loaded) return this.current;
     const map = await this.loader();
     const keyValue = (this.root as Record<string, unknown>)[this.localKey];
     if (keyValue === undefined || keyValue === null) {
-      this.#loaded = true;
-      return this.#current;
+      this.loaded = true;
+      return this.current;
     }
     const row = map.get(toKey(keyValue));
-    this.#current = row ? this.createEntity(row) : null;
-    this.#loaded = true;
-    return this.#current;
+    this.current = row ? this.createEntity(row) : null;
+    this.loaded = true;
+    return this.current;
   }
 
   get(): TChild | null {
-    return this.#current;
+    return this.current;
   }
 
   set(data: Partial<TChild> | TChild | null): TChild | null {
@@ -90,20 +103,20 @@ export class DefaultHasOneReference<TChild extends object> implements HasOneRefe
     }
 
     const entity = hasEntityMeta(data) ? (data as TChild) : this.createEntity(data as Row);
-    if (this.#current && this.#current !== entity) {
+    if (this.current && this.current !== entity) {
       this.ctx.registerRelationChange(
         this.root,
         this.relationKey,
         this.rootTable,
         this.relationName,
         this.relation,
-        { kind: 'remove', entity: this.#current }
+        { kind: 'remove', entity: this.current }
       );
     }
 
     this.assignForeignKey(entity);
-    this.#current = entity;
-    this.#loaded = true;
+    this.current = entity;
+    this.loaded = true;
 
     this.ctx.registerRelationChange(
       this.root,
@@ -117,19 +130,15 @@ export class DefaultHasOneReference<TChild extends object> implements HasOneRefe
     return entity;
   }
 
-  isLoaded(): boolean {
-    return this.#loaded;
-  }
-
   toJSON(): TChild | null {
-    return this.#current;
+    return this.current;
   }
 
   private detachCurrent(): TChild | null {
-    const previous = this.#current;
+    const previous = this.current;
     if (!previous) return null;
-    this.#current = null;
-    this.#loaded = true;
+    this.current = null;
+    this.loaded = true;
     this.ctx.registerRelationChange(
       this.root,
       this.relationKey,
@@ -156,7 +165,7 @@ export class DefaultHasOneReference<TChild extends object> implements HasOneRefe
     if (keyValue === undefined || keyValue === null) return;
     const row = getHydrationRecord(this.meta, this.relationName, keyValue);
     if (!row) return;
-    this.#current = this.createEntity(row);
-    this.#loaded = true;
+    this.current = this.createEntity(row);
+    this.loaded = true;
   }
 }

package/src/orm/relations/many-to-many.ts

@@ -15,7 +15,19 @@ const hideInternal = (obj: object, keys: string[]): void => {
     Object.defineProperty(obj, key, {
       value: obj[key],
       writable: false,
-      configurable: true,  // Must be configurable for Proxy get trap to work properly
+      configurable: false,
+      enumerable: false
+    });
+  }
+};
+
+const hideWritable = (obj: object, keys: string[]): void => {
+  for (const key of keys) {
+    const value = obj[key as keyof typeof obj];
+    Object.defineProperty(obj, key, {
+      value,
+      writable: true,
+      configurable: true,
       enumerable: false
     });
   }
@@ -30,8 +42,8 @@ const hideInternal = (obj: object, keys: string[]): void => {
  */
 export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefined = undefined>
   implements ManyToManyCollection<TTarget, TPivot> {
-  #loaded = false;
-  #items: TTarget[] = [];
+  private loaded = false;
+  private items: TTarget[] = [];
 
   /**
    * @param ctx The entity context for tracking changes.
@@ -56,6 +68,7 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
     private readonly localKey: string
   ) {
     hideInternal(this, ['ctx', 'meta', 'root', 'relationName', 'relation', 'rootTable', 'loader', 'createEntity', 'localKey']);
+    hideWritable(this, ['loaded', 'items']);
     this.hydrateFromCache();
   }
 
@@ -64,19 +77,19 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
    * @returns A promise that resolves to the array of target entities.
    */
   async load(): Promise<TTarget[]> {
-    if (this.#loaded) return this.#items;
+    if (this.loaded) return this.items;
     const map = await this.loader();
     const key = toKey(this.root[this.localKey]);
     const rows = map.get(key) ?? [];
-    this.#items = rows.map(row => {
+    this.items = rows.map(row => {
       const entity = this.createEntity(row);
       if ((row as { _pivot?: unknown })._pivot) {
         (entity as { _pivot?: unknown })._pivot = (row as { _pivot?: unknown })._pivot;
       }
       return entity;
     });
-    this.#loaded = true;
-    return this.#items;
+    this.loaded = true;
+    return this.items;
   }
 
   /**
@@ -84,21 +97,21 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
    * @returns Array of target entities.
    */
   getItems(): TTarget[] {
-    return this.#items;
+    return this.items;
   }
 
   /**
    * Array-compatible length for testing frameworks.
    */
   get length(): number {
-    return this.#items.length;
+    return this.items.length;
   }
 
   /**
    * Enables iteration over the collection like an array.
    */
   [Symbol.iterator](): Iterator<TTarget> {
-    return this.#items[Symbol.iterator]();
+    return this.items[Symbol.iterator]();
   }
 
   /**
@@ -109,13 +122,13 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
   attach(target: TTarget | number | string): void {
     const entity = this.ensureEntity(target);
     const id = this.extractId(entity);
-    if (id != null && this.#items.some(item => this.extractId(item) === id)) {
+    if (id != null && this.items.some(item => this.extractId(item) === id)) {
       return;
     }
-    if (id == null && this.#items.includes(entity)) {
+    if (id == null && this.items.includes(entity)) {
       return;
     }
-    this.#items.push(entity);
+    this.items.push(entity);
     this.ctx.registerRelationChange(
       this.root,
       this.relationKey,
@@ -138,10 +151,10 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
 
     if (id == null) return;
 
-    const existing = this.#items.find(item => this.extractId(item) === id);
+    const existing = this.items.find(item => this.extractId(item) === id);
     if (!existing) return;
 
-    this.#items = this.#items.filter(item => this.extractId(item) !== id);
+    this.items = this.items.filter(item => this.extractId(item) !== id);
     this.ctx.registerRelationChange(
       this.root,
       this.relationKey,
@@ -160,7 +173,7 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
   async syncByIds(ids: (number | string)[]): Promise<void> {
     await this.load();
     const normalized = new Set(ids.map(id => toKey(id)));
-    const currentIds = new Set(this.#items.map(item => toKey(this.extractId(item))));
+    const currentIds = new Set(this.items.map(item => toKey(this.extractId(item))));
 
     for (const id of normalized) {
       if (!currentIds.has(id)) {
@@ -168,7 +181,7 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
       }
     }
 
-    for (const item of [...this.#items]) {
+    for (const item of [...this.items]) {
       const itemId = toKey(this.extractId(item));
       if (!normalized.has(itemId)) {
         this.detach(item);
@@ -176,10 +189,6 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
     }
   }
 
-  isLoaded(): boolean {
-    return this.#loaded;
-  }
-
   private ensureEntity(target: TTarget | number | string): TTarget {
     if (typeof target === 'number' || typeof target === 'string') {
       const stub: Record<string, unknown> = {
@@ -211,7 +220,7 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
     if (keyValue === undefined || keyValue === null) return;
     const rows = getHydrationRows(this.meta, this.relationName, keyValue);
     if (!rows?.length) return;
-    this.#items = rows.map(row => {
+    this.items = rows.map(row => {
       const entity = this.createEntity(row);
       // eslint-disable-next-line @typescript-eslint/no-explicit-any
       if ((row as { _pivot?: unknown })._pivot) {
@@ -219,10 +228,10 @@ export class DefaultManyToManyCollection<TTarget, TPivot extends object | undefi
       }
       return entity;
     });
-    this.#loaded = true;
+    this.loaded = true;
   }
 
   toJSON(): TTarget[] {
-    return this.#items;
+    return this.items;
   }
 }