@rws-framework/db 4.0.1 → 4.1.1

package/dist/models/core/RWSModel.d.ts

@@ -15,6 +15,7 @@ declare class RWSModel<T> implements IModel {
     static _BANNED_KEYS: string[];
     static allModels: OpModelType<any>[];
     static _CUT_KEYS: string[];
+    private _relationFields;
     private postLoadExecuted;
     constructor(data?: any);
     isPostLoadExecuted(): boolean;
@@ -86,5 +87,6 @@ declare class RWSModel<T> implements IModel {
     private hydratePrePopulatedRelations;
     static getDb(): DBService;
     reload(): Promise<RWSModel<T> | null>;
+    getPropertyValue(key: string): any;
 }
 export { RWSModel };

package/dist/models/core/RWSModel.js

@@ -27,6 +27,8 @@ class RWSModel {
     static _BANNED_KEYS = ['_collection'];
     static allModels = [];
     static _CUT_KEYS = [];
+    // Store relation foreign key fields for reload() functionality
+    _relationFields = {};
     postLoadExecuted = false;
     constructor(data = null) {
         if (!this.getCollection()) {
@@ -420,8 +422,15 @@ class RWSModel {
                     // Check if it's already a full object with data or just an ID reference
                     if (relationData.id || Object.keys(relationData).length > 1) {
                         // Create new instance and hydrate ONLY basic fields, NO RELATIONS
+                        // Respect ignored_keys from child model
+                        const childIgnoredKeys = ModelClass._CUT_KEYS || [];
                         const relatedInstance = new ModelClass();
-                        await relatedInstance._asyncFill(relationData, false, false, true);
+                        // Filter relationData to exclude ignored keys
+                        const filteredData = { ...relationData };
+                        for (const ignoredKey of childIgnoredKeys) {
+                            delete filteredData[ignoredKey];
+                        }
+                        await relatedInstance._asyncFill(filteredData, false, false, true);
                         this[key] = relatedInstance;
                     }
                 }
@@ -439,8 +448,38 @@ class RWSModel {
                         // Handle singular inverse relation as a single object
                         if (typeof relationData === 'object' && relationData !== null &&
                             (relationData.id || Object.keys(relationData).length > 1)) {
+                            const childIgnoredKeys = ModelClass._CUT_KEYS || [];
                             const relatedInstance = new ModelClass();
-                            await relatedInstance._asyncFill(relationData, false, false, true);
+                            // Check relation metadata to identify foreign key fields that need to be preserved
+                            const tempInstance = new ModelClass();
+                            const childClassFields = FieldsHelper_1.FieldsHelper.getAllClassFields(tempInstance.constructor);
+                            const [childRelOneData, childRelManyData] = await Promise.all([
+                                RelationUtils_1.RelationUtils.getRelationOneMeta(tempInstance, childClassFields),
+                                RelationUtils_1.RelationUtils.getRelationManyMeta(tempInstance, childClassFields)
+                            ]);
+                            // Store foreign key fields from relation metadata
+                            for (const relKey in childRelOneData) {
+                                const relMeta = childRelOneData[relKey];
+                                const foreignKeyField = relMeta.hydrationField; // e.g., 'avatar_id', 'knowledge_id'
+                                if (foreignKeyField && relationData[foreignKeyField] !== undefined) {
+                                    relatedInstance._relationFields[foreignKeyField] = relationData[foreignKeyField];
+                                    relatedInstance[foreignKeyField] = relationData[foreignKeyField];
+                                }
+                            }
+                            for (const relKey in childRelManyData) {
+                                const relMeta = childRelManyData[relKey];
+                                const foreignKeyField = relMeta.foreignKey; // Use foreignKey for inverse relations
+                                if (foreignKeyField && relationData[foreignKeyField] !== undefined) {
+                                    relatedInstance._relationFields[foreignKeyField] = relationData[foreignKeyField];
+                                    relatedInstance[foreignKeyField] = relationData[foreignKeyField];
+                                }
+                            }
+                            // Filter relationData to exclude ignored keys
+                            const filteredData = { ...relationData };
+                            for (const ignoredKey of childIgnoredKeys) {
+                                delete filteredData[ignoredKey];
+                            }
+                            await relatedInstance._asyncFill(filteredData, false, false, true);
                             this[key] = relatedInstance;
                         }
                     }
@@ -449,8 +488,38 @@ class RWSModel {
                         const relatedInstances = [];
                         for (const itemData of relationData) {
                             if (typeof itemData === 'object' && itemData !== null) {
+                                const childIgnoredKeys = ModelClass._CUT_KEYS || [];
                                 const relatedInstance = new ModelClass();
-                                await relatedInstance._asyncFill(itemData, false, false, true);
+                                // Check relation metadata to identify foreign key fields that need to be preserved
+                                const tempInstance = new ModelClass();
+                                const childClassFields = FieldsHelper_1.FieldsHelper.getAllClassFields(tempInstance.constructor);
+                                const [childRelOneData, childRelManyData] = await Promise.all([
+                                    RelationUtils_1.RelationUtils.getRelationOneMeta(tempInstance, childClassFields),
+                                    RelationUtils_1.RelationUtils.getRelationManyMeta(tempInstance, childClassFields)
+                                ]);
+                                // Store foreign key fields from relation metadata
+                                for (const relKey in childRelOneData) {
+                                    const relMeta = childRelOneData[relKey];
+                                    const foreignKeyField = relMeta.hydrationField; // e.g., 'avatar_id', 'knowledge_id'
+                                    if (foreignKeyField && itemData[foreignKeyField] !== undefined) {
+                                        relatedInstance._relationFields[foreignKeyField] = itemData[foreignKeyField];
+                                        relatedInstance[foreignKeyField] = itemData[foreignKeyField];
+                                    }
+                                }
+                                for (const relKey in childRelManyData) {
+                                    const relMeta = childRelManyData[relKey];
+                                    const foreignKeyField = relMeta.foreignKey; // Use foreignKey for inverse relations
+                                    if (foreignKeyField && itemData[foreignKeyField] !== undefined) {
+                                        relatedInstance._relationFields[foreignKeyField] = itemData[foreignKeyField];
+                                        relatedInstance[foreignKeyField] = itemData[foreignKeyField];
+                                    }
+                                }
+                                // Filter itemData to exclude ignored keys
+                                const filteredData = { ...itemData };
+                                for (const ignoredKey of childIgnoredKeys) {
+                                    delete filteredData[ignoredKey];
+                                }
+                                await relatedInstance._asyncFill(filteredData, false, false, true);
                                 relatedInstances.push(relatedInstance);
                             }
                         }
@@ -474,17 +543,54 @@ class RWSModel {
         else {
             where[pk] = this[pk];
         }
-        // Find the fresh data from database
-        const freshData = await FindUtils_1.FindUtils.findOneBy(this.constructor, { conditions: where });
+        // Get ignored keys from model's @RWSCollection decorator
+        const ignoredKeys = (this.constructor._CUT_KEYS || []);
+        let fields = undefined;
+        // Build fields list excluding ignored ones if there are ignored keys
+        if (ignoredKeys.length > 0) {
+            // Get proper database fields from model annotations
+            const annotations = await ModelUtils_1.ModelUtils.getModelAnnotations(this.constructor);
+            // Get scalar fields (TrackType decorated fields)
+            const scalarFields = ModelUtils_1.ModelUtils.getModelScalarFields(this);
+            // Get relation fields from annotations
+            const relationFields = Object.keys(annotations).filter(key => annotations[key].annotationType === 'Relation' ||
+                annotations[key].annotationType === 'InverseRelation');
+            // Combine all database fields
+            const allDbFields = [...scalarFields, ...relationFields];
+            // Filter out ignored keys
+            fields = allDbFields.filter(field => !ignoredKeys.includes(field));
+            // Always include id if not ignored
+            if (!fields.includes('id') && !ignoredKeys.includes('id')) {
+                fields.push('id');
+            }
+        }
+        // Find the fresh data from database with field filtering
+        const freshData = await FindUtils_1.FindUtils.findOneBy(this.constructor, {
+            conditions: where,
+            fields: fields
+        });
         if (!freshData) {
             return null;
         }
         // Convert the fresh instance back to plain data for hydration
         const plainData = await freshData.toMongo();
+        // Preserve foreign key fields from _relationFields to ensure relations can be hydrated
+        for (const key in this._relationFields) {
+            if (plainData[key] === undefined) {
+                plainData[key] = this._relationFields[key];
+            }
+        }
         // Hydrate current instance with fresh data including relations
         await this._asyncFill(plainData, true, true, true);
         return this;
     }
+    // Helper method to get property with fallback to stored relation fields
+    getPropertyValue(key) {
+        if (this.hasOwnProperty(key) || this[key] !== undefined) {
+            return this[key];
+        }
+        return this._relationFields[key];
+    }
 }
 exports.RWSModel = RWSModel;
 __decorate([

package/dist/models/utils/HydrateUtils.d.ts

@@ -10,4 +10,8 @@ export declare class HydrateUtils {
     static hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {
         [key: string]: any;
     }, postLoadExecute?: boolean): Promise<void>;
+    /**
+     * Get all database fields for a model excluding ignored ones
+     */
+    private static getFieldsExcludingIgnored;
 }

package/dist/models/utils/HydrateUtils.js

@@ -19,9 +19,11 @@ class HydrateUtils {
                 foreignKeyFields.add(relationMeta.hydrationField);
             }
         }
+        // Get ignored keys from model's @RWSCollection decorator
+        const ignoredKeys = (model).constructor._CUT_KEYS || [];
         for (const key in data) {
             if (data.hasOwnProperty(key)) {
-                if (!fullDataMode && (model).constructor._CUT_KEYS.includes(key)) {
+                if (!fullDataMode && ignoredKeys.includes(key)) {
                     continue;
                 }
                 // Skip relation property names
@@ -52,20 +54,25 @@ class HydrateUtils {
         }
     }
     static async hydrateRelations(model, relManyData, relOneData, seriesHydrationfields, fullDataMode, data, postLoadExecute = false) {
+        const ignoredKeys = (model).constructor._CUT_KEYS || [];
         // Handle many-to-many relations
         for (const key in relManyData) {
-            if (!fullDataMode && model.constructor._CUT_KEYS.includes(key)) {
+            if (!fullDataMode && ignoredKeys.includes(key)) {
                 continue;
             }
             const relMeta = relManyData[key];
             const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(model, relMeta.key);
             if (relationEnabled) {
                 const pk = ModelUtils_1.ModelUtils.findPrimaryKeyFields(model.constructor);
+                // Get child model ignored keys to pass to find operations
+                const childIgnoredKeys = relMeta.inversionModel._CUT_KEYS || [];
+                const childFields = childIgnoredKeys.length > 0 ? await this.getFieldsExcludingIgnored(relMeta.inversionModel, childIgnoredKeys) : undefined;
                 if (relMeta.singular) {
                     model[relMeta.key] = await relMeta.inversionModel.findOneBy({
                         conditions: {
                             [relMeta.foreignKey]: data[pk]
                         },
+                        fields: childFields,
                         allowRelations: false,
                         cancelPostLoad: !postLoadExecute
                     });
@@ -75,6 +82,7 @@ class HydrateUtils {
                         conditions: {
                             [relMeta.foreignKey]: data[pk]
                         },
+                        fields: childFields,
                         allowRelations: false,
                         cancelPostLoad: !postLoadExecute
                     });
@@ -83,7 +91,7 @@ class HydrateUtils {
         }
         // Handle one-to-one relations
         for (const key in relOneData) {
-            if (!fullDataMode && model.constructor._CUT_KEYS.includes(key)) {
+            if (!fullDataMode && ignoredKeys.includes(key)) {
                 continue;
             }
             const relMeta = relOneData[key];
@@ -101,13 +109,19 @@ class HydrateUtils {
                 else {
                     where[pk] = data[relMeta.hydrationField];
                 }
-                model[relMeta.key] = await relMeta.model.findOneBy({ conditions: where }, { allowRelations: false });
+                // Get child model ignored keys to pass to find operation
+                const childIgnoredKeys = relMeta.model._CUT_KEYS || [];
+                const childFields = childIgnoredKeys.length > 0 ? await this.getFieldsExcludingIgnored(relMeta.model, childIgnoredKeys) : undefined;
+                model[relMeta.key] = await relMeta.model.findOneBy({
+                    conditions: where,
+                    fields: childFields
+                }, { allowRelations: false });
             }
             else if (relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]) {
                 const newRelModel = await relMeta.model.create(data[relMeta.key]);
                 model[relMeta.key] = await newRelModel.save();
             }
-            const cutKeys = model.constructor._CUT_KEYS;
+            const cutKeys = ignoredKeys;
             const trackedField = Object.keys((await ModelUtils_1.ModelUtils.getModelAnnotations(model.constructor))).includes(relMeta.hydrationField);
             if (!cutKeys.includes(relMeta.hydrationField) && !trackedField) {
                 cutKeys.push(relMeta.hydrationField);
@@ -115,5 +129,30 @@ class HydrateUtils {
             // seriesHydrationfields.push(relMeta.hydrationField);
         }
     }
+    /**
+     * Get all database fields for a model excluding ignored ones
+     */
+    static async getFieldsExcludingIgnored(modelClass, ignoredKeys) {
+        if (!ignoredKeys || ignoredKeys.length === 0) {
+            return undefined;
+        }
+        // Get proper database fields from model annotations
+        const tempInstance = new modelClass();
+        const annotations = await ModelUtils_1.ModelUtils.getModelAnnotations(modelClass);
+        // Get scalar fields (TrackType decorated fields)
+        const scalarFields = ModelUtils_1.ModelUtils.getModelScalarFields(tempInstance);
+        // Get relation fields from annotations
+        const relationFields = Object.keys(annotations).filter(key => annotations[key].annotationType === 'Relation' ||
+            annotations[key].annotationType === 'InverseRelation');
+        // Combine all database fields
+        const allDbFields = [...scalarFields, ...relationFields];
+        // Filter out ignored keys
+        const filteredFields = allDbFields.filter(field => !ignoredKeys.includes(field));
+        // Always include id if not ignored
+        if (!filteredFields.includes('id') && !ignoredKeys.includes('id')) {
+            filteredFields.push('id');
+        }
+        return filteredFields.length > 0 ? filteredFields : undefined;
+    }
 }
 exports.HydrateUtils = HydrateUtils;

package/dist/models/utils/ModelUtils.js

@@ -55,7 +55,7 @@ class ModelUtils {
         return baseClass.prototype.isPrototypeOf(constructor.prototype);
     }
     static getModelScalarFields(model) {
-        return FieldsHelper_1.FieldsHelper.getAllClassFields(model)
+        return FieldsHelper_1.FieldsHelper.getAllClassFields(model.constructor)
             .filter((item) => item.indexOf('TrackType') === 0)
             .map((item) => item.split(':').at(-1));
     }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "4.0.1",
+  "version": "4.1.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/models/core/RWSModel.ts

@@ -27,6 +27,9 @@ class RWSModel<T> implements IModel {
     static _BANNED_KEYS = ['_collection'];
     static allModels: OpModelType<any>[] = [];
     static _CUT_KEYS: string[] = [];
+    
+    // Store relation foreign key fields for reload() functionality
+    private _relationFields: Record<string, any> = {};
 
     private postLoadExecuted: boolean = false;
 
@@ -544,8 +547,17 @@ class RWSModel<T> implements IModel {
                     // Check if it's already a full object with data or just an ID reference
                     if (relationData.id || Object.keys(relationData).length > 1) {
                         // Create new instance and hydrate ONLY basic fields, NO RELATIONS
+                        // Respect ignored_keys from child model
+                        const childIgnoredKeys = (ModelClass as OpModelType<any>)._CUT_KEYS || [];
                         const relatedInstance = new ModelClass();
-                        await relatedInstance._asyncFill(relationData, false, false, true);
+                        
+                        // Filter relationData to exclude ignored keys
+                        const filteredData = { ...relationData };
+                        for (const ignoredKey of childIgnoredKeys) {
+                            delete filteredData[ignoredKey];
+                        }
+                        
+                        await relatedInstance._asyncFill(filteredData, false, false, true);
                         this[key] = relatedInstance;
                     }
                 }
@@ -565,8 +577,43 @@ class RWSModel<T> implements IModel {
                         // Handle singular inverse relation as a single object
                         if (typeof relationData === 'object' && relationData !== null && 
                             (relationData.id || Object.keys(relationData).length > 1)) {
+                            const childIgnoredKeys = (ModelClass as OpModelType<any>)._CUT_KEYS || [];
                             const relatedInstance = new ModelClass();
-                            await relatedInstance._asyncFill(relationData, false, false, true);
+                            
+                            // Check relation metadata to identify foreign key fields that need to be preserved
+                            const tempInstance = new ModelClass();
+                            const childClassFields = FieldsHelper.getAllClassFields(tempInstance.constructor);
+                            const [childRelOneData, childRelManyData] = await Promise.all([
+                                RelationUtils.getRelationOneMeta(tempInstance, childClassFields),
+                                RelationUtils.getRelationManyMeta(tempInstance, childClassFields)
+                            ]);
+                            
+                            // Store foreign key fields from relation metadata
+                            for (const relKey in childRelOneData) {
+                                const relMeta = childRelOneData[relKey];
+                                const foreignKeyField = relMeta.hydrationField; // e.g., 'avatar_id', 'knowledge_id'
+                                if (foreignKeyField && relationData[foreignKeyField] !== undefined) {
+                                    relatedInstance._relationFields[foreignKeyField] = relationData[foreignKeyField];
+                                    relatedInstance[foreignKeyField] = relationData[foreignKeyField];
+                                }
+                            }
+                            
+                            for (const relKey in childRelManyData) {
+                                const relMeta = childRelManyData[relKey];
+                                const foreignKeyField = relMeta.foreignKey; // Use foreignKey for inverse relations
+                                if (foreignKeyField && relationData[foreignKeyField] !== undefined) {
+                                    relatedInstance._relationFields[foreignKeyField] = relationData[foreignKeyField];
+                                    relatedInstance[foreignKeyField] = relationData[foreignKeyField];
+                                }
+                            }
+                            
+                            // Filter relationData to exclude ignored keys
+                            const filteredData = { ...relationData };
+                            for (const ignoredKey of childIgnoredKeys) {
+                                delete filteredData[ignoredKey];
+                            }
+                            
+                            await relatedInstance._asyncFill(filteredData, false, false, true);
                             this[key] = relatedInstance;
                         }
                     } else if (Array.isArray(relationData) && relationData.length > 0) {
@@ -574,8 +621,43 @@ class RWSModel<T> implements IModel {
                         const relatedInstances = [];
                         for (const itemData of relationData) {
                             if (typeof itemData === 'object' && itemData !== null) {
+                                const childIgnoredKeys = (ModelClass as OpModelType<any>)._CUT_KEYS || [];
                                 const relatedInstance = new ModelClass();
-                                await relatedInstance._asyncFill(itemData, false, false, true);
+                                
+                                // Check relation metadata to identify foreign key fields that need to be preserved
+                                const tempInstance = new ModelClass();
+                                const childClassFields = FieldsHelper.getAllClassFields(tempInstance.constructor);
+                                const [childRelOneData, childRelManyData] = await Promise.all([
+                                    RelationUtils.getRelationOneMeta(tempInstance, childClassFields),
+                                    RelationUtils.getRelationManyMeta(tempInstance, childClassFields)
+                                ]);
+                                
+                                // Store foreign key fields from relation metadata
+                                for (const relKey in childRelOneData) {
+                                    const relMeta = childRelOneData[relKey];
+                                    const foreignKeyField = relMeta.hydrationField; // e.g., 'avatar_id', 'knowledge_id'
+                                    if (foreignKeyField && itemData[foreignKeyField] !== undefined) {
+                                        relatedInstance._relationFields[foreignKeyField] = itemData[foreignKeyField];
+                                        relatedInstance[foreignKeyField] = itemData[foreignKeyField];
+                                    }
+                                }
+                                
+                                for (const relKey in childRelManyData) {
+                                    const relMeta = childRelManyData[relKey];
+                                    const foreignKeyField = relMeta.foreignKey; // Use foreignKey for inverse relations
+                                    if (foreignKeyField && itemData[foreignKeyField] !== undefined) {
+                                        relatedInstance._relationFields[foreignKeyField] = itemData[foreignKeyField];
+                                        relatedInstance[foreignKeyField] = itemData[foreignKeyField];
+                                    }
+                                }
+                                
+                                // Filter itemData to exclude ignored keys
+                                const filteredData = { ...itemData };
+                                for (const ignoredKey of childIgnoredKeys) {
+                                    delete filteredData[ignoredKey];
+                                }
+                                
+                                await relatedInstance._asyncFill(filteredData, false, false, true);
                                 relatedInstances.push(relatedInstance);
                             }
                         }
@@ -604,8 +686,41 @@ class RWSModel<T> implements IModel {
             where[pk as string] = this[pk as string]
         }         
         
-        // Find the fresh data from database
-        const freshData = await FindUtils.findOneBy(this.constructor as OpModelType<any>, { conditions: where });
+        // Get ignored keys from model's @RWSCollection decorator
+        const ignoredKeys = ((this.constructor as OpModelType<any>)._CUT_KEYS || []);
+        let fields: string[] | undefined = undefined;
+        
+        // Build fields list excluding ignored ones if there are ignored keys
+        if (ignoredKeys.length > 0) {
+            // Get proper database fields from model annotations
+            const annotations = await ModelUtils.getModelAnnotations(this.constructor as OpModelType<any>);
+            
+            // Get scalar fields (TrackType decorated fields)
+            const scalarFields = ModelUtils.getModelScalarFields(this);
+            
+            // Get relation fields from annotations
+            const relationFields = Object.keys(annotations).filter(key => 
+                annotations[key].annotationType === 'Relation' || 
+                annotations[key].annotationType === 'InverseRelation'
+            );
+            
+            // Combine all database fields
+            const allDbFields = [...scalarFields, ...relationFields];
+            
+            // Filter out ignored keys
+            fields = allDbFields.filter(field => !ignoredKeys.includes(field));
+            
+            // Always include id if not ignored
+            if (!fields.includes('id') && !ignoredKeys.includes('id')) {
+                fields.push('id');
+            }
+        }
+        
+        // Find the fresh data from database with field filtering
+        const freshData = await FindUtils.findOneBy(this.constructor as OpModelType<any>, { 
+            conditions: where,
+            fields: fields
+        });
         
         if (!freshData) {
             return null;
@@ -614,11 +729,26 @@ class RWSModel<T> implements IModel {
         // Convert the fresh instance back to plain data for hydration
         const plainData = await freshData.toMongo();
         
+        // Preserve foreign key fields from _relationFields to ensure relations can be hydrated
+        for (const key in this._relationFields) {
+            if (plainData[key] === undefined) {
+                plainData[key] = this._relationFields[key];
+            }
+        }
+        
         // Hydrate current instance with fresh data including relations
         await this._asyncFill(plainData, true, true, true);
         
         return this;
     }
+    
+    // Helper method to get property with fallback to stored relation fields
+    getPropertyValue(key: string): any {
+        if (this.hasOwnProperty(key) || this[key] !== undefined) {
+            return this[key];
+        }
+        return this._relationFields[key];
+    }
 }
 
 export { RWSModel };

package/src/models/utils/FindUtils.ts

@@ -130,7 +130,7 @@ export class FindUtils {
             } : null;
             
             const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams, prismaOptions);
-
+        
             if (dbData.length) {
                 const instanced: T[] = [];
 

package/src/models/utils/HydrateUtils.ts

@@ -5,6 +5,7 @@ import { TimeSeriesUtils } from "./TimeSeriesUtils";
 import { RelationUtils } from "./RelationUtils";
 import { OpModelType } from "..";
 import { ModelUtils } from "./ModelUtils";
+import { FieldsHelper } from "../../helper/FieldsHelper";
 import chalk from 'chalk';
 
 export class HydrateUtils {
@@ -20,9 +21,12 @@ export class HydrateUtils {
             }
         }
         
+        // Get ignored keys from model's @RWSCollection decorator
+        const ignoredKeys = ((model).constructor as OpModelType<any>)._CUT_KEYS || [];
+        
         for (const key in data) {
             if (data.hasOwnProperty(key)) {
-                if (!fullDataMode && ((model).constructor as OpModelType<any>)._CUT_KEYS.includes(key)) {
+                if (!fullDataMode && ignoredKeys.includes(key)) {
                     continue;
                 }
 
@@ -62,9 +66,11 @@ export class HydrateUtils {
     }
 
     static async hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: { [key: string]: any }, postLoadExecute = false) {
+        const ignoredKeys = ((model).constructor as OpModelType<any>)._CUT_KEYS || [];
+        
         // Handle many-to-many relations
         for (const key in relManyData) {
-            if (!fullDataMode && (model as any).constructor._CUT_KEYS.includes(key)) {
+            if (!fullDataMode && ignoredKeys.includes(key)) {
                 continue;
             }
 
@@ -72,16 +78,19 @@ export class HydrateUtils {
 
             const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
 
-
-
             if (relationEnabled) {
                 const pk = ModelUtils.findPrimaryKeyFields(model.constructor as OpModelType<any>) as string;
 
+                // Get child model ignored keys to pass to find operations
+                const childIgnoredKeys = (relMeta.inversionModel as OpModelType<any>)._CUT_KEYS || [];
+                const childFields = childIgnoredKeys.length > 0 ? await this.getFieldsExcludingIgnored(relMeta.inversionModel, childIgnoredKeys) : undefined;
+
                 if (relMeta.singular) {
                     model[relMeta.key] = await relMeta.inversionModel.findOneBy({
                         conditions: {
                             [relMeta.foreignKey]: data[pk]
                         },
+                        fields: childFields,
                         allowRelations: false,
                         cancelPostLoad: !postLoadExecute
                     });
@@ -90,6 +99,7 @@ export class HydrateUtils {
                         conditions: {
                             [relMeta.foreignKey]: data[pk]
                         },
+                        fields: childFields,
                         allowRelations: false,
                         cancelPostLoad: !postLoadExecute
                     });
@@ -99,7 +109,7 @@ export class HydrateUtils {
 
         // Handle one-to-one relations
         for (const key in relOneData) {
-            if (!fullDataMode && ((model as any).constructor as OpModelType<any>)._CUT_KEYS.includes(key)) {
+            if (!fullDataMode && ignoredKeys.includes(key)) {
                 continue;
             }
 
@@ -122,14 +132,21 @@ export class HydrateUtils {
                     where[pk as string] = data[relMeta.hydrationField]
                 }
 
-                model[relMeta.key] = await relMeta.model.findOneBy({ conditions: where }, { allowRelations: false });
+                // Get child model ignored keys to pass to find operation
+                const childIgnoredKeys = (relMeta.model as OpModelType<any>)._CUT_KEYS || [];
+                const childFields = childIgnoredKeys.length > 0 ? await this.getFieldsExcludingIgnored(relMeta.model, childIgnoredKeys) : undefined;
+
+                model[relMeta.key] = await relMeta.model.findOneBy({ 
+                    conditions: where,
+                    fields: childFields
+                }, { allowRelations: false });
             }
             else if (relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]) {
                 const newRelModel: RWSModel<any> = await relMeta.model.create(data[relMeta.key]);
                 model[relMeta.key] = await newRelModel.save();
             }
 
-            const cutKeys = ((model.constructor as OpModelType<any>)._CUT_KEYS as string[]);
+            const cutKeys = ignoredKeys;
 
             const trackedField = Object.keys((await ModelUtils.getModelAnnotations(model.constructor as OpModelType<any>))).includes(relMeta.hydrationField);
 
@@ -140,4 +157,39 @@ export class HydrateUtils {
             // seriesHydrationfields.push(relMeta.hydrationField);
         }
     }
+
+    /**
+     * Get all database fields for a model excluding ignored ones
+     */
+    private static async getFieldsExcludingIgnored(modelClass: OpModelType<any>, ignoredKeys: string[]): Promise<string[] | undefined> {
+        if (!ignoredKeys || ignoredKeys.length === 0) {
+            return undefined;
+        }
+
+        // Get proper database fields from model annotations
+        const tempInstance = new modelClass();
+        const annotations = await ModelUtils.getModelAnnotations(modelClass);
+        
+        // Get scalar fields (TrackType decorated fields)
+        const scalarFields = ModelUtils.getModelScalarFields(tempInstance);
+        
+        // Get relation fields from annotations
+        const relationFields = Object.keys(annotations).filter(key => 
+            annotations[key].annotationType === 'Relation' || 
+            annotations[key].annotationType === 'InverseRelation'
+        );
+        
+        // Combine all database fields
+        const allDbFields = [...scalarFields, ...relationFields];
+        
+        // Filter out ignored keys
+        const filteredFields = allDbFields.filter(field => !ignoredKeys.includes(field));
+        
+        // Always include id if not ignored
+        if (!filteredFields.includes('id') && !ignoredKeys.includes('id')) {
+            filteredFields.push('id');
+        }
+
+        return filteredFields.length > 0 ? filteredFields : undefined;
+    }
 }

package/src/models/utils/ModelUtils.ts

@@ -70,7 +70,7 @@ export class ModelUtils {
     }
 
     static getModelScalarFields(model: RWSModel<any>): string[] {       
-        return FieldsHelper.getAllClassFields(model)
+        return FieldsHelper.getAllClassFields(model.constructor)
                 .filter((item: string) => item.indexOf('TrackType') === 0)
                 .map((item: string) => item.split(':').at(-1));
     }