@rws-framework/db 4.1.0 → 4.1.1

package/dist/models/core/RWSModel.js

@@ -422,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;
                     }
                 }
@@ -441,6 +448,7 @@ 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();
                             // Check relation metadata to identify foreign key fields that need to be preserved
                             const tempInstance = new ModelClass();
@@ -466,7 +474,12 @@ class RWSModel {
                                     relatedInstance[foreignKeyField] = relationData[foreignKeyField];
                                 }
                             }
-                            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;
                         }
                     }
@@ -475,6 +488,7 @@ class RWSModel {
                         const relatedInstances = [];
                         for (const itemData of relationData) {
                             if (typeof itemData === 'object' && itemData !== null) {
+                                const childIgnoredKeys = ModelClass._CUT_KEYS || [];
                                 const relatedInstance = new ModelClass();
                                 // Check relation metadata to identify foreign key fields that need to be preserved
                                 const tempInstance = new ModelClass();
@@ -500,7 +514,12 @@ class RWSModel {
                                         relatedInstance[foreignKeyField] = itemData[foreignKeyField];
                                     }
                                 }
-                                await relatedInstance._asyncFill(itemData, false, false, true);
+                                // 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);
                             }
                         }
@@ -524,8 +543,32 @@ 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;
         }

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.1.0",
+  "version": "4.1.1",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/src/models/core/RWSModel.ts

@@ -547,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;
                     }
                 }
@@ -568,6 +577,7 @@ 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();
                             
                             // Check relation metadata to identify foreign key fields that need to be preserved
@@ -597,7 +607,13 @@ class RWSModel<T> implements IModel {
                                 }
                             }
                             
-                            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;
                         }
                     } else if (Array.isArray(relationData) && relationData.length > 0) {
@@ -605,6 +621,7 @@ 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();
                                 
                                 // Check relation metadata to identify foreign key fields that need to be preserved
@@ -634,7 +651,13 @@ class RWSModel<T> implements IModel {
                                     }
                                 }
                                 
-                                await relatedInstance._asyncFill(itemData, false, false, true);
+                                // 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);
                             }
                         }
@@ -663,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;

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));
     }