@rws-framework/db 3.12.5 → 4.1.0

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;
@@ -72,7 +73,20 @@ declare class RWSModel<T> implements IModel {
     static count(where?: {
         [k: string]: any;
     }): Promise<number>;
+    /**
+     * Build Prisma include object for relation preloading
+     */
+    static buildPrismaIncludes<T extends RWSModel<T>>(this: OpModelType<T>, fields?: string[]): Promise<any>;
+    /**
+     * Check if relations are already populated from Prisma includes
+     */
+    private checkRelationsPrePopulated;
+    /**
+     * Hydrate pre-populated relations from Prisma includes (one level only)
+     */
+    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()) {
@@ -107,10 +109,26 @@ class RWSModel {
             collections_to_models[model.getCollection()] = model;
         });
         const seriesHydrationfields = [];
-        if (allowRelations) {
+        // Check if relations are already populated from Prisma includes
+        const relationsAlreadyPopulated = this.checkRelationsPrePopulated(data, relOneData, relManyData);
+        if (allowRelations && !relationsAlreadyPopulated) {
+            // Use traditional relation hydration if not pre-populated
             await HydrateUtils_1.HydrateUtils.hydrateRelations(this, relManyData, relOneData, seriesHydrationfields, fullDataMode, data);
         }
-        // Process regular fields and time series
+        else if (allowRelations && relationsAlreadyPopulated) {
+            // Relations are already populated from Prisma, just assign them directly
+            await this.hydratePrePopulatedRelations(data, relOneData, relManyData);
+            // Create a copy of data without relation fields to prevent overwriting hydrated relations
+            const dataWithoutRelations = { ...data };
+            for (const key in relOneData) {
+                delete dataWithoutRelations[key];
+            }
+            for (const key in relManyData) {
+                delete dataWithoutRelations[key];
+            }
+            data = dataWithoutRelations;
+        }
+        // Process regular fields and time series (excluding relations when pre-populated)
         await HydrateUtils_1.HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
         if (!this.isPostLoadExecuted() && postLoadExecute) {
             await this.postLoad();
@@ -311,6 +329,187 @@ class RWSModel {
     static async count(where = {}) {
         return await this.services.dbService.count(this, where);
     }
+    /**
+     * Build Prisma include object for relation preloading
+     */
+    static async buildPrismaIncludes(fields) {
+        const tempInstance = new this();
+        const classFields = FieldsHelper_1.FieldsHelper.getAllClassFields(this);
+        const [relOneData, relManyData] = await Promise.all([
+            this.getRelationOneMeta(tempInstance, classFields),
+            this.getRelationManyMeta(tempInstance, classFields)
+        ]);
+        // Get relations configuration from @RWSCollection decorator
+        const allowedRelations = this._RELATIONS || {};
+        const hasRelationsConfig = Object.keys(allowedRelations).length > 0;
+        const includes = {};
+        // Helper function to determine if a relation should be included
+        const shouldIncludeRelation = (relationName) => {
+            // If relations config exists, only include relations that are explicitly enabled
+            if (hasRelationsConfig) {
+                if (!allowedRelations[relationName]) {
+                    return false;
+                }
+            }
+            // If fields are specified, only include if relation is in fields array
+            if (fields && fields.length > 0) {
+                return fields.includes(relationName);
+            }
+            // If no fields specified but relations config exists, include enabled relations
+            if (hasRelationsConfig) {
+                return allowedRelations[relationName] === true;
+            }
+            // If no relations config and no fields specified, include all relations
+            return true;
+        };
+        // Add one-to-one and many-to-one relations
+        for (const key in relOneData) {
+            if (shouldIncludeRelation(key)) {
+                includes[key] = true;
+            }
+        }
+        // Add one-to-many relations
+        for (const key in relManyData) {
+            if (shouldIncludeRelation(key)) {
+                includes[key] = true;
+            }
+        }
+        return Object.keys(includes).length > 0 ? includes : null;
+    }
+    /**
+     * Check if relations are already populated from Prisma includes
+     */
+    checkRelationsPrePopulated(data, relOneData, relManyData) {
+        // Check if any relation key in data contains object data instead of just ID
+        for (const key in relOneData) {
+            if (data[key] && typeof data[key] === 'object' && data[key] !== null) {
+                // For one-to-one relations, check if it has an id or if it's a full object
+                if (data[key].id || Object.keys(data[key]).length > 1) {
+                    return true;
+                }
+            }
+        }
+        for (const key in relManyData) {
+            const relationValue = data[key];
+            const relMeta = relManyData[key];
+            if (relMeta.singular) {
+                // Singular inverse relation - should be a single object
+                if (relationValue && typeof relationValue === 'object' && relationValue !== null &&
+                    (relationValue.id || Object.keys(relationValue).length > 1)) {
+                    return true;
+                }
+            }
+            else if (relationValue && Array.isArray(relationValue) && relationValue.length > 0) {
+                // Regular one-to-many relations - should be arrays
+                if (typeof relationValue[0] === 'object' && relationValue[0] !== null) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+    /**
+     * Hydrate pre-populated relations from Prisma includes (one level only)
+     */
+    async hydratePrePopulatedRelations(data, relOneData, relManyData) {
+        // Handle one-to-one and many-to-one relations
+        for (const key in relOneData) {
+            if (data[key] && typeof data[key] === 'object' && data[key] !== null) {
+                const relationData = data[key];
+                const relMeta = relOneData[key];
+                const ModelClass = relMeta.model; // Use the model class directly from metadata
+                if (ModelClass) {
+                    // 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
+                        const relatedInstance = new ModelClass();
+                        await relatedInstance._asyncFill(relationData, false, false, true);
+                        this[key] = relatedInstance;
+                    }
+                }
+            }
+        }
+        // Handle one-to-many relations
+        for (const key in relManyData) {
+            if (data[key]) {
+                const relationData = data[key];
+                const relMeta = relManyData[key];
+                const ModelClass = relMeta.inversionModel; // Use the model class directly from metadata
+                if (ModelClass) {
+                    // Check if this is a singular inverse relation
+                    if (relMeta.singular && !Array.isArray(relationData)) {
+                        // Handle singular inverse relation as a single object
+                        if (typeof relationData === 'object' && relationData !== null &&
+                            (relationData.id || Object.keys(relationData).length > 1)) {
+                            const relatedInstance = new ModelClass();
+                            // 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];
+                                }
+                            }
+                            await relatedInstance._asyncFill(relationData, false, false, true);
+                            this[key] = relatedInstance;
+                        }
+                    }
+                    else if (Array.isArray(relationData) && relationData.length > 0) {
+                        // Handle regular one-to-many relations as arrays
+                        const relatedInstances = [];
+                        for (const itemData of relationData) {
+                            if (typeof itemData === 'object' && itemData !== null) {
+                                const relatedInstance = new ModelClass();
+                                // 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];
+                                    }
+                                }
+                                await relatedInstance._asyncFill(itemData, false, false, true);
+                                relatedInstances.push(relatedInstance);
+                            }
+                        }
+                        this[key] = relatedInstances;
+                    }
+                }
+            }
+        }
+    }
     static getDb() {
         return this.services.dbService;
     }
@@ -325,7 +524,29 @@ class RWSModel {
         else {
             where[pk] = this[pk];
         }
-        return await FindUtils_1.FindUtils.findOneBy(this.constructor, { conditions: where });
+        // Find the fresh data from database
+        const freshData = await FindUtils_1.FindUtils.findOneBy(this.constructor, { conditions: where });
+        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;

package/dist/models/interfaces/OpModelType.d.ts

@@ -35,6 +35,7 @@ export interface OpModelType<T> {
     count(where?: {
         [k: string]: any;
     }): Promise<number>;
+    buildPrismaIncludes<T extends RWSModel<T>>(this: OpModelType<T>, fields?: string[]): Promise<any>;
     isSubclass<T extends RWSModel<T>, C extends new () => T>(constructor: C, baseClass: new () => T): boolean;
     getModelAnnotations<T extends unknown>(constructor: new () => T): Promise<Record<string, {
         annotationType: string;

package/dist/models/utils/FindUtils.js

@@ -10,7 +10,11 @@ class FindUtils {
         const fullData = findParams?.fullData ?? false;
         opModel.checkForInclusionWithThrow('');
         const collection = Reflect.get(opModel, '_collection');
-        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
+        // Build Prisma includes for relation preloading if relations are allowed
+        const prismaOptions = allowRelations ? {
+            include: await opModel.buildPrismaIncludes(fields)
+        } : null;
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering, prismaOptions);
         if (dbData) {
             const inst = new opModel();
             const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
@@ -25,7 +29,11 @@ class FindUtils {
         const fullData = findParams?.fullData ?? false;
         const collection = Reflect.get(opModel, '_collection');
         opModel.checkForInclusionWithThrow(opModel.name);
-        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering);
+        // Build Prisma includes for relation preloading if relations are allowed
+        const prismaOptions = allowRelations ? {
+            include: await opModel.buildPrismaIncludes(fields)
+        } : null;
+        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering, prismaOptions);
         if (dbData) {
             const inst = new opModel();
             const loaded = await inst._asyncFill(dbData, fullData, allowRelations, findParams?.cancelPostLoad ? false : true);
@@ -43,7 +51,11 @@ class FindUtils {
         opModel.checkForInclusionWithThrow(opModel.name);
         try {
             const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
-            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            // Build Prisma includes for relation preloading if relations are allowed
+            const prismaOptions = allowRelations ? {
+                include: await opModel.buildPrismaIncludes(fields)
+            } : null;
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams, prismaOptions);
             if (dbData.length) {
                 const instanced = [];
                 for (const data of dbData) {
@@ -68,7 +80,11 @@ class FindUtils {
         const collection = Reflect.get(opModel, '_collection');
         opModel.checkForInclusionWithThrow(opModel.name);
         try {
-            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            // Build Prisma includes for relation preloading if relations are allowed
+            const prismaOptions = allowRelations ? {
+                include: await opModel.buildPrismaIncludes(fields)
+            } : null;
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams, prismaOptions);
             if (dbData.length) {
                 const instanced = [];
                 for (const data of dbData) {

package/dist/models/utils/HydrateUtils.js

@@ -11,14 +11,27 @@ const chalk_1 = __importDefault(require("chalk"));
 class HydrateUtils {
     static async hydrateDataFields(model, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data) {
         const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(model);
+        // Build a set of foreign key field names to skip
+        const foreignKeyFields = new Set();
+        for (const relationName in relOneData) {
+            const relationMeta = relOneData[relationName];
+            if (relationMeta.hydrationField) {
+                foreignKeyFields.add(relationMeta.hydrationField);
+            }
+        }
         for (const key in data) {
             if (data.hasOwnProperty(key)) {
                 if (!fullDataMode && (model).constructor._CUT_KEYS.includes(key)) {
                     continue;
                 }
+                // Skip relation property names
                 if (Object.keys(relOneData).includes(key)) {
                     continue;
                 }
+                // Skip foreign key field names
+                if (foreignKeyFields.has(key)) {
+                    continue;
+                }
                 if (seriesHydrationfields.includes(key)) {
                     continue;
                 }

package/dist/services/DBService.d.ts

@@ -24,9 +24,9 @@ declare class DBService {
     watchCollection(collectionName: string, preRun: () => void): Promise<any>;
     insert(data: any, collection: string, isTimeSeries?: boolean): Promise<any>;
     update(data: any, collection: string, pk: string | string[]): Promise<IModel>;
-    findOneBy(collection: string, conditions: any, fields?: string[] | null, ordering?: OrderByType): Promise<IModel | null>;
+    findOneBy(collection: string, conditions: any, fields?: string[] | null, ordering?: OrderByType, prismaOptions?: any): Promise<IModel | null>;
     delete(collection: string, conditions: any): Promise<void>;
-    findBy(collection: string, conditions: any, fields?: string[] | null, ordering?: OrderByType, pagination?: IPaginationParams): Promise<IModel[]>;
+    findBy(collection: string, conditions: any, fields?: string[] | null, ordering?: OrderByType, pagination?: IPaginationParams, prismaOptions?: any): Promise<IModel[]>;
     collectionExists(collection_name: string): Promise<boolean>;
     createTimeSeriesCollection(collection_name: string): Promise<Collection<ITimeSeries>>;
     private getCollectionHandler;

package/dist/services/DBService.js

@@ -126,13 +126,25 @@ class DBService {
         });
         return await this.findOneBy(collection, where);
     }
-    async findOneBy(collection, conditions, fields = null, ordering = null) {
+    async findOneBy(collection, conditions, fields = null, ordering = null, prismaOptions = null) {
         const params = { where: conditions };
         if (fields) {
             params.select = {};
             fields.forEach((fieldName) => {
                 params.select[fieldName] = true;
             });
+            // Add relation fields to select instead of using include when fields are specified
+            if (prismaOptions?.include) {
+                Object.keys(prismaOptions.include).forEach(relationField => {
+                    if (fields.includes(relationField)) {
+                        params.select[relationField] = true;
+                    }
+                });
+            }
+        }
+        else if (prismaOptions?.include) {
+            // Only use include when no fields are specified
+            params.include = prismaOptions.include;
         }
         if (ordering) {
             params.orderBy = this.convertOrderingToPrismaFormat(ordering);
@@ -144,13 +156,25 @@ class DBService {
         await this.getCollectionHandler(collection).deleteMany({ where: conditions });
         return;
     }
-    async findBy(collection, conditions, fields = null, ordering = null, pagination = null) {
+    async findBy(collection, conditions, fields = null, ordering = null, pagination = null, prismaOptions = null) {
         const params = { where: conditions };
         if (fields) {
             params.select = {};
             fields.forEach((fieldName) => {
                 params.select[fieldName] = true;
             });
+            // Add relation fields to select instead of using include when fields are specified
+            if (prismaOptions?.include) {
+                Object.keys(prismaOptions.include).forEach(relationField => {
+                    if (fields.includes(relationField)) {
+                        params.select[relationField] = true;
+                    }
+                });
+            }
+        }
+        else if (prismaOptions?.include) {
+            // Only use include when no fields are specified
+            params.include = prismaOptions.include;
         }
         if (ordering) {
             params.orderBy = this.convertOrderingToPrismaFormat(ordering);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rws-framework/db",
   "private": false,
-  "version": "3.12.5",
+  "version": "4.1.0",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -24,6 +24,7 @@
     "tsconfig-paths-webpack-plugin": "^4.1.0"
   },
   "devDependencies": {
+    "@types/node": "^22.0.0",
     "@types/xml2js": "^0.4.14",
     "typescript": "^5.7.2"
   },

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;
 
@@ -129,12 +132,28 @@ class RWSModel<T> implements IModel {
     
         const seriesHydrationfields: string[] = []; 
 
+        // Check if relations are already populated from Prisma includes
+        const relationsAlreadyPopulated = this.checkRelationsPrePopulated(data, relOneData, relManyData);
 
-        if (allowRelations) {
+        if (allowRelations && !relationsAlreadyPopulated) {
+            // Use traditional relation hydration if not pre-populated
             await HydrateUtils.hydrateRelations(this, relManyData, relOneData, seriesHydrationfields, fullDataMode, data);
+        } else if (allowRelations && relationsAlreadyPopulated) {
+            // Relations are already populated from Prisma, just assign them directly
+            await this.hydratePrePopulatedRelations(data, relOneData, relManyData);
+            
+            // Create a copy of data without relation fields to prevent overwriting hydrated relations
+            const dataWithoutRelations = { ...data };
+            for (const key in relOneData) {
+                delete dataWithoutRelations[key];
+            }
+            for (const key in relManyData) {
+                delete dataWithoutRelations[key];
+            }
+            data = dataWithoutRelations;
         }
     
-        // Process regular fields and time series
+        // Process regular fields and time series (excluding relations when pre-populated)
         await HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
     
         if(!this.isPostLoadExecuted() && postLoadExecute){            
@@ -416,10 +435,216 @@ class RWSModel<T> implements IModel {
         return this.services.dbService;
     }
 
-    public static async count(where: {[k: string]: any} = {}): Promise<number>{
+    public static async count(where: {[k: string]: any} = {}): Promise<number>{        
         return await this.services.dbService.count(this as OpModelType<any>, where);
     }
 
+    /**
+     * Build Prisma include object for relation preloading
+     */
+    public static async buildPrismaIncludes<T extends RWSModel<T>>(this: OpModelType<T>, fields?: string[]): Promise<any> {
+        const tempInstance = new this();
+        const classFields = FieldsHelper.getAllClassFields(this);
+        
+        const [relOneData, relManyData] = await Promise.all([
+            this.getRelationOneMeta(tempInstance, classFields),
+            this.getRelationManyMeta(tempInstance, classFields)
+        ]);
+
+        // Get relations configuration from @RWSCollection decorator
+        const allowedRelations = this._RELATIONS || {};
+        const hasRelationsConfig = Object.keys(allowedRelations).length > 0;
+
+        const includes: any = {};
+        
+        // Helper function to determine if a relation should be included
+        const shouldIncludeRelation = (relationName: string): boolean => {
+            // If relations config exists, only include relations that are explicitly enabled
+            if (hasRelationsConfig) {
+                if (!allowedRelations[relationName]) {
+                    return false;
+                }
+            }
+            
+            // If fields are specified, only include if relation is in fields array
+            if (fields && fields.length > 0) {
+                return fields.includes(relationName);
+            }
+            
+            // If no fields specified but relations config exists, include enabled relations
+            if (hasRelationsConfig) {
+                return allowedRelations[relationName] === true;
+            }
+            
+            // If no relations config and no fields specified, include all relations
+            return true;
+        };
+        
+        // Add one-to-one and many-to-one relations
+        for (const key in relOneData) {
+            if (shouldIncludeRelation(key)) {
+                includes[key] = true;
+            }
+        }
+        
+        // Add one-to-many relations
+        for (const key in relManyData) {
+            if (shouldIncludeRelation(key)) {
+                includes[key] = true;
+            }
+        }
+        
+        return Object.keys(includes).length > 0 ? includes : null;
+    }
+
+    /**
+     * Check if relations are already populated from Prisma includes
+     */
+    private checkRelationsPrePopulated(data: any, relOneData: any, relManyData: any): boolean {
+        // Check if any relation key in data contains object data instead of just ID
+        for (const key in relOneData) {
+            if (data[key] && typeof data[key] === 'object' && data[key] !== null) {
+                // For one-to-one relations, check if it has an id or if it's a full object
+                if (data[key].id || Object.keys(data[key]).length > 1) {
+                    return true;
+                }
+            }
+        }
+        
+        for (const key in relManyData) {
+            const relationValue = data[key];
+            const relMeta = relManyData[key];
+            
+            if (relMeta.singular) {
+                // Singular inverse relation - should be a single object
+                if (relationValue && typeof relationValue === 'object' && relationValue !== null && 
+                    (relationValue.id || Object.keys(relationValue).length > 1)) {
+                    return true;
+                }
+            } else if (relationValue && Array.isArray(relationValue) && relationValue.length > 0) {
+                // Regular one-to-many relations - should be arrays
+                if (typeof relationValue[0] === 'object' && relationValue[0] !== null) {
+                    return true;
+                }
+            }
+        }
+        
+        return false;
+    }
+
+    /**
+     * Hydrate pre-populated relations from Prisma includes (one level only)
+     */
+    private async hydratePrePopulatedRelations(data: any, relOneData: any, relManyData: any): Promise<void> {
+        // Handle one-to-one and many-to-one relations
+        for (const key in relOneData) {
+            if (data[key] && typeof data[key] === 'object' && data[key] !== null) {
+                const relationData = data[key];
+                const relMeta = relOneData[key];
+                const ModelClass = relMeta.model; // Use the model class directly from metadata
+                
+                if (ModelClass) {
+                    // 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
+                        const relatedInstance = new ModelClass();
+                        await relatedInstance._asyncFill(relationData, false, false, true);
+                        this[key] = relatedInstance;
+                    }
+                }
+            }
+        }
+
+        // Handle one-to-many relations
+        for (const key in relManyData) {
+            if (data[key]) {
+                const relationData = data[key];
+                const relMeta = relManyData[key];
+                const ModelClass = relMeta.inversionModel; // Use the model class directly from metadata
+                
+                if (ModelClass) {
+                    // Check if this is a singular inverse relation
+                    if (relMeta.singular && !Array.isArray(relationData)) {
+                        // Handle singular inverse relation as a single object
+                        if (typeof relationData === 'object' && relationData !== null && 
+                            (relationData.id || Object.keys(relationData).length > 1)) {
+                            const relatedInstance = new ModelClass();
+                            
+                            // 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];
+                                }
+                            }
+                            
+                            await relatedInstance._asyncFill(relationData, false, false, true);
+                            this[key] = relatedInstance;
+                        }
+                    } else if (Array.isArray(relationData) && relationData.length > 0) {
+                        // Handle regular one-to-many relations as arrays
+                        const relatedInstances = [];
+                        for (const itemData of relationData) {
+                            if (typeof itemData === 'object' && itemData !== null) {
+                                const relatedInstance = new ModelClass();
+                                
+                                // 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];
+                                    }
+                                }
+                                
+                                await relatedInstance._asyncFill(itemData, false, false, true);
+                                relatedInstances.push(relatedInstance);
+                            }
+                        }
+                        this[key] = relatedInstances;
+                    }
+                }
+            }
+        }
+    }
+
     public static getDb(): DBService
     {
         return this.services.dbService;
@@ -438,7 +663,35 @@ class RWSModel<T> implements IModel {
             where[pk as string] = this[pk as string]
         }         
         
-        return await FindUtils.findOneBy(this.constructor as OpModelType<any>, { conditions: where });
+        // Find the fresh data from database
+        const freshData = await FindUtils.findOneBy(this.constructor as OpModelType<any>, { conditions: where });
+        
+        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: string): any {
+        if (this.hasOwnProperty(key) || this[key] !== undefined) {
+            return this[key];
+        }
+        return this._relationFields[key];
     }
 }
 

package/src/models/interfaces/OpModelType.ts

@@ -63,6 +63,10 @@ export interface OpModelType<T> {
         preRun: () => void
     ): Promise<any>;
     count(where?: { [k: string]: any }): Promise<number>;
+    buildPrismaIncludes<T extends RWSModel<T>>(
+        this: OpModelType<T>,
+        fields?: string[]
+    ): Promise<any>;
     isSubclass<T extends RWSModel<T>, C extends new () => T>(
         constructor: C,
         baseClass: new () => T

package/src/models/utils/FindUtils.ts

@@ -20,10 +20,14 @@ export class FindUtils {
 
         opModel.checkForInclusionWithThrow('');
 
-
         const collection = Reflect.get(opModel, '_collection');
-        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering);
-
+        
+        // Build Prisma includes for relation preloading if relations are allowed
+        const prismaOptions = allowRelations ? {
+            include: await opModel.buildPrismaIncludes(fields)
+        } : null;
+        
+        const dbData = await opModel.services.dbService.findOneBy(collection, conditions, fields, ordering, prismaOptions);
 
         if (dbData) {
             const inst: T = new (opModel as { new(): T })();
@@ -47,7 +51,13 @@ export class FindUtils {
         const collection = Reflect.get(opModel, '_collection');
         opModel.checkForInclusionWithThrow(opModel.name);
 
-        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering);
+        // Build Prisma includes for relation preloading if relations are allowed
+        const prismaOptions = allowRelations ? {
+            include: await opModel.buildPrismaIncludes(fields)
+        } : null;
+
+        const dbData = await opModel.services.dbService.findOneBy(collection, { id }, fields, ordering, prismaOptions);
+
 
         if (dbData) {
             const inst: T = new (opModel as { new(): T })();
@@ -72,12 +82,18 @@ export class FindUtils {
         opModel.checkForInclusionWithThrow(opModel.name);
         try {
             const paginateParams = findParams?.pagination ? findParams?.pagination : undefined;
-            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            
+            // Build Prisma includes for relation preloading if relations are allowed
+            const prismaOptions = allowRelations ? {
+                include: await opModel.buildPrismaIncludes(fields)
+            } : null;
+            
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams, prismaOptions);
 
             if (dbData.length) {
                 const instanced: T[] = [];
 
-                for (const data of dbData) {
+                for (const data of dbData) {      
                     const inst: T = new (opModel as { new(): T })();
 
                     instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true)) as T);
@@ -108,7 +124,13 @@ export class FindUtils {
         const collection = Reflect.get(opModel, '_collection');
         opModel.checkForInclusionWithThrow(opModel.name);
         try {
-            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);
+            // Build Prisma includes for relation preloading if relations are allowed
+            const prismaOptions = allowRelations ? {
+                include: await opModel.buildPrismaIncludes(fields)
+            } : null;
+            
+            const dbData = await opModel.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams, prismaOptions);
+        
             if (dbData.length) {
                 const instanced: T[] = [];
 
@@ -116,6 +138,7 @@ export class FindUtils {
                     const inst: T = new (opModel as { new(): T })();                    
                     instanced.push((await inst._asyncFill(data, fullData, allowRelations, findParams?.cancelPostLoad ? false : true)) as T);
                 }
+                
 
                 return instanced;
             }

package/src/models/utils/HydrateUtils.ts

@@ -10,16 +10,32 @@ import chalk from 'chalk';
 export class HydrateUtils {
     static async hydrateDataFields(model: RWSModel<any>, collections_to_models: { [key: string]: any }, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: { [key: string]: any }) {
         const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(model);
+        
+        // Build a set of foreign key field names to skip
+        const foreignKeyFields = new Set<string>();
+        for (const relationName in relOneData) {
+            const relationMeta = relOneData[relationName];
+            if (relationMeta.hydrationField) {
+                foreignKeyFields.add(relationMeta.hydrationField);
+            }
+        }
+        
         for (const key in data) {
             if (data.hasOwnProperty(key)) {
                 if (!fullDataMode && ((model).constructor as OpModelType<any>)._CUT_KEYS.includes(key)) {
                     continue;
                 }
 
+                // Skip relation property names
                 if (Object.keys(relOneData).includes(key)) {
                     continue;
                 }
 
+                // Skip foreign key field names
+                if (foreignKeyFields.has(key)) {
+                    continue;
+                }
+
                 if (seriesHydrationfields.includes(key)) {
                     continue;
                 }

package/src/services/DBService.ts

@@ -172,7 +172,7 @@ class DBService {
     }
   
 
-    async findOneBy(collection: string, conditions: any, fields: string[] | null = null, ordering: OrderByType = null): Promise<IModel|null>
+    async findOneBy(collection: string, conditions: any, fields: string[] | null = null, ordering: OrderByType = null, prismaOptions: any = null): Promise<IModel|null>
     {    
         const params: any = { where: conditions };
 
@@ -181,6 +181,18 @@ class DBService {
             fields.forEach((fieldName: string) => {        
                 params.select[fieldName] = true;
             });    
+            
+            // Add relation fields to select instead of using include when fields are specified
+            if(prismaOptions?.include) {
+                Object.keys(prismaOptions.include).forEach(relationField => {
+                    if (fields.includes(relationField)) {
+                        params.select[relationField] = true;
+                    }
+                });
+            }
+        } else if(prismaOptions?.include) {
+            // Only use include when no fields are specified
+            params.include = prismaOptions.include;
         }
 
         if(ordering){
@@ -203,7 +215,8 @@ class DBService {
         conditions: any, 
         fields: string[] | null = null, 
         ordering: OrderByType = null, 
-        pagination: IPaginationParams = null): Promise<IModel[]>
+        pagination: IPaginationParams = null,
+        prismaOptions: any = null): Promise<IModel[]>
     {    
         const params: any ={ where: conditions };
 
@@ -212,6 +225,18 @@ class DBService {
             fields.forEach((fieldName: string) => {        
                 params.select[fieldName] = true;
             });    
+            
+            // Add relation fields to select instead of using include when fields are specified
+            if(prismaOptions?.include) {
+                Object.keys(prismaOptions.include).forEach(relationField => {
+                    if (fields.includes(relationField)) {
+                        params.select[relationField] = true;
+                    }
+                });
+            }
+        } else if(prismaOptions?.include) {
+            // Only use include when no fields are specified
+            params.include = prismaOptions.include;
         }
 
         if(ordering){
@@ -303,7 +328,7 @@ class DBService {
         return this;
     }
 
-    public async count<T = any>(opModel: OpModelType<T>, where: {[k: string]: any} = {}): Promise<number>{
+    public async count<T = any>(opModel: OpModelType<T>, where: {[k: string]: any} = {}): Promise<number>{        
         return await this.getCollectionHandler(opModel._collection).count({where});
     }
 

package/tsconfig.json

@@ -14,7 +14,8 @@
       "allowSyntheticDefaultImports": true,
       "sourceMap": false,      
       "declaration": true,   
-      "outDir": "./dist"       
+      "outDir": "./dist",
+      "types": ["node"]       
     },
     "include": [
       "src"