@rws-framework/db 4.1.5 → 4.1.7

package/dist/decorators/InverseRelation.d.ts

@@ -7,6 +7,9 @@ export interface InverseRelationOpts {
     singular?: boolean;
     relationName?: string;
     mappingName?: string;
+    orderBy?: {
+        [field: string]: 'asc' | 'desc';
+    };
 }
 declare function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, relationOptions?: Partial<InverseRelationOpts>): (target: any, key: string) => void;
 export default InverseRelation;

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

@@ -17,6 +17,10 @@ declare class RWSModel<T> implements IModel {
     static _CUT_KEYS: string[];
     private _relationFields;
     private postLoadExecuted;
+    /**
+     * Store relation foreign key fields for later hydration
+     */
+    private storeRelationFields;
     constructor(data?: any);
     isPostLoadExecuted(): boolean;
     setPostLoadExecuted(): void;

package/dist/models/core/RWSModel.js

@@ -30,6 +30,17 @@ class RWSModel {
     // Store relation foreign key fields for reload() functionality
     _relationFields = {};
     postLoadExecuted = false;
+    /**
+     * Store relation foreign key fields for later hydration
+     */
+    storeRelationFields(data, relOneData) {
+        for (const relationName in relOneData) {
+            const relationMeta = relOneData[relationName];
+            if (relationMeta.hydrationField && data[relationMeta.hydrationField]) {
+                this._relationFields[relationMeta.hydrationField] = data[relationMeta.hydrationField];
+            }
+        }
+    }
     constructor(data = null) {
         if (!this.getCollection()) {
             throw new Error('Model must have a collection defined');
@@ -109,6 +120,15 @@ class RWSModel {
             collections_to_models[model.getCollection()] = model;
         });
         const seriesHydrationfields = [];
+        // Always preprocess foreign keys to relation objects, even if allowRelations is false
+        // This is necessary because toMongo() expects relation objects to exist
+        try {
+            data = await HydrateUtils_1.HydrateUtils.preprocessForeignKeys(data, this, relOneData);
+        }
+        catch (error) {
+            console.error('Error in preprocessForeignKeys:', error);
+            throw error;
+        }
         // Check if relations are already populated from Prisma includes
         const relationsAlreadyPopulated = this.checkRelationsPrePopulated(data, relOneData, relManyData);
         if (allowRelations && !relationsAlreadyPopulated) {
@@ -118,16 +138,25 @@ class RWSModel {
         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
+            // Create a copy of data without relation fields AND foreign key fields to prevent conflicts
             const dataWithoutRelations = { ...data };
             for (const key in relOneData) {
-                delete dataWithoutRelations[key];
+                delete dataWithoutRelations[key]; // Remove relation field (e.g., 'screenFile')
+                const relationMeta = relOneData[key];
+                if (relationMeta.hydrationField) {
+                    delete dataWithoutRelations[relationMeta.hydrationField]; // Remove foreign key field (e.g., 'screen_file_id')
+                }
             }
             for (const key in relManyData) {
-                delete dataWithoutRelations[key];
+                delete dataWithoutRelations[key]; // Remove relation array fields
             }
             data = dataWithoutRelations;
         }
+        else {
+            // Even if relations are disabled, we still need to store relation foreign key fields
+            // for later hydration when reload() is called
+            this.storeRelationFields(data, relOneData);
+        }
         // 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) {
@@ -161,33 +190,29 @@ class RWSModel {
         // Get relation metadata to determine how to handle each relation
         const classFields = FieldsHelper_1.FieldsHelper.getAllClassFields(this.constructor);
         const relOneData = await this.getRelationOneMeta(classFields);
+        // Check if this is a new model (no ID) to handle relations differently during creation
+        const isNewModel = !this.id;
         for (const key in this) {
             if (await this.hasRelation(key)) {
                 const relationMeta = relOneData[key];
                 if (relationMeta) {
-                    // Use connect on relations that are either:
-                    // 1. Required (required: true)
-                    // 2. Have explicitly set cascade options (metaOpts.cascade)
-                    const hasExplicitCascade = relationMeta.cascade && Object.keys(relationMeta.cascade).length > 0;
-                    const shouldUseConnect = relationMeta.required || hasExplicitCascade;
-                    if (shouldUseConnect) {
-                        // Relations with required=true or explicit cascade → use connect
-                        if (this[key] === null) {
+                    // Always use Prisma relation syntax when relation objects exist
+                    // This ensures compatibility with Prisma's expected format
+                    if (this[key] === null || this[key] === undefined) {
+                        // Only add disconnect if this is an update (not a creation)
+                        if (!isNewModel) {
                             data[key] = { disconnect: true };
                         }
-                        else if (this[key] && this[key].id) {
-                            data[key] = { connect: { id: this[key].id } };
-                        }
+                        // For new models, we simply don't include the relation field
                     }
-                    else {
-                        // Simple optional relations → use foreign key field directly
-                        const foreignKeyField = relationMeta.hydrationField;
-                        if (this[key] === null) {
-                            data[foreignKeyField] = null;
-                        }
-                        else if (this[key] && this[key].id) {
-                            data[foreignKeyField] = this[key].id;
-                        }
+                    else if (this[key] && this[key].id) {
+                        data[key] = { connect: { id: this[key].id } };
+                    }
+                    else if (this[key] && typeof this[key] === 'object' && !this[key].id) {
+                        // Handle case where we have a relation object but it might not have an ID yet
+                        // This could happen if the relation object is also being created
+                        // In this case, we might want to create the relation first or handle it differently
+                        console.warn(`Relation ${key} has an object without ID. This might cause issues during creation.`);
                     }
                 }
                 continue;
@@ -375,7 +400,16 @@ class RWSModel {
         // Add one-to-many relations (without nesting)
         for (const key in relManyData) {
             if (shouldIncludeRelation(key)) {
-                includes[key] = true; // Only load this level, no nested relations
+                const relationMeta = relManyData[key];
+                if (relationMeta.orderBy) {
+                    // Add Prisma orderBy to the relation include
+                    includes[key] = {
+                        orderBy: relationMeta.orderBy
+                    };
+                }
+                else {
+                    includes[key] = true; // Only load this level, no nested relations
+                }
             }
         }
         return Object.keys(includes).length > 0 ? includes : null;

package/dist/models/types/RelationTypes.d.ts

@@ -24,6 +24,9 @@ export type RelManyMetaType<T extends IRWSModel> = {
         inversionModel: OpModelType<T>;
         foreignKey: string;
         singular: boolean;
+        orderBy?: {
+            [field: string]: 'asc' | 'desc';
+        };
     };
 };
 export {};

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

@@ -2,6 +2,10 @@ import { RWSModel } from "../core/RWSModel";
 import { RelManyMetaType, RelOneMetaType } from "../types/RelationTypes";
 import { IRWSModel } from "../../types/IRWSModel";
 export declare class HydrateUtils {
+    /**
+     * Preprocess database data to convert foreign keys to relation objects when relations are not already populated
+     */
+    static preprocessForeignKeys(data: any, model: RWSModel<any>, relOneData: RelOneMetaType<IRWSModel>): Promise<any>;
     static hydrateDataFields(model: RWSModel<any>, collections_to_models: {
         [key: string]: any;
     }, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {

package/dist/models/utils/HydrateUtils.js

@@ -9,6 +9,41 @@ const RelationUtils_1 = require("./RelationUtils");
 const ModelUtils_1 = require("./ModelUtils");
 const chalk_1 = __importDefault(require("chalk"));
 class HydrateUtils {
+    /**
+     * Preprocess database data to convert foreign keys to relation objects when relations are not already populated
+     */
+    static async preprocessForeignKeys(data, model, relOneData) {
+        const processedData = { ...data };
+        // For each relation, handle different scenarios during creation and updates
+        for (const relationName in relOneData) {
+            const relationMeta = relOneData[relationName];
+            const foreignKeyField = relationMeta.hydrationField; // e.g., "tutorial_id"
+            const relationField = relationMeta.key; // e.g., "tutorial"
+            // Scenario 1: We have a foreign key value but no relation object (or the relation is just an ID)
+            if (foreignKeyField in data && data[foreignKeyField] !== null && data[foreignKeyField] !== undefined &&
+                (!data[relationField] || typeof data[relationField] !== 'object')) {
+                // Create a minimal relation object with just the ID
+                // This allows toMongo() to work properly without requiring full relation loading
+                processedData[relationField] = { id: data[foreignKeyField] };
+            }
+            // Scenario 2: We have a relation object but no foreign key field (common during creation)
+            // Ensure the foreign key field exists when we have a valid relation object
+            else if (data[relationField] && typeof data[relationField] === 'object' &&
+                data[relationField].id &&
+                (!(foreignKeyField in data) || data[foreignKeyField] === null || data[foreignKeyField] === undefined)) {
+                // Set the foreign key field from the relation object's ID
+                processedData[foreignKeyField] = data[relationField].id;
+            }
+            // Scenario 3: Both relation object and foreign key exist, ensure they're consistent
+            else if (data[relationField] && typeof data[relationField] === 'object' &&
+                data[relationField].id && foreignKeyField in data &&
+                data[foreignKeyField] !== data[relationField].id) {
+                // Prioritize the relation object's ID
+                processedData[foreignKeyField] = data[relationField].id;
+            }
+        }
+        return processedData;
+    }
     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
@@ -97,9 +132,14 @@ class HydrateUtils {
             const relMeta = relOneData[key];
             const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(model, relMeta.key);
             if (!data[relMeta.hydrationField] && relMeta.required) {
-                // Only throw error if this is a fresh load, not a reload of existing model
-                if (!model.id) {
-                    throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${model.constructor.name}.`);
+                // Only throw error if this is a fresh load AND we're not in creation mode
+                // During creation, required relations might not have their foreign key set yet
+                if (!model.id && data[relMeta.key]) {
+                    // We have the relation object but not the foreign key - this is okay during creation
+                    continue;
+                }
+                else if (!model.id && !data[relMeta.key]) {
+                    throw new Error(`Required relation "${relMeta.key}" is missing in model ${model.constructor.name}.`);
                 }
                 // For existing models (reloads), skip loading this relation if the field is missing
                 continue;

package/dist/models/utils/RelationUtils.js

@@ -42,7 +42,8 @@ class RelationUtils {
                         key: resolvedMetadata.key,
                         inversionModel: resolvedMetadata.inversionModel,
                         foreignKey: resolvedMetadata.foreignKey,
-                        singular: resolvedMetadata?.singular || false
+                        singular: resolvedMetadata?.singular || false,
+                        orderBy: resolvedMetadata?.orderBy || null
                     };
                 }
             }

package/dist/services/DBService.d.ts

@@ -35,11 +35,6 @@ declare class DBService {
     count<T = any>(opModel: OpModelType<T>, where?: {
         [k: string]: any;
     }): Promise<number>;
-    /**
-     * Convert foreign key fields to Prisma relation syntax
-     * Handles common patterns like user_id -> creator, avatar_id -> avatar, etc.
-     */
-    private convertForeignKeysToRelations;
     getPrismaClient(): PrismaClient;
 }
 export { DBService, IDBClientCreate };

package/dist/services/DBService.js

@@ -120,11 +120,9 @@ class DBService {
                 delete data[cKey];
             }
         }
-        // Convert foreign key fields to Prisma relation syntax
-        const processedData = this.convertForeignKeysToRelations(data);
         await prismaCollection.update({
             where,
-            data: processedData,
+            data,
         });
         return await this.findOneBy(collection, where);
     }
@@ -246,57 +244,6 @@ class DBService {
     async count(opModel, where = {}) {
         return await this.getCollectionHandler(opModel._collection).count({ where });
     }
-    /**
-     * Convert foreign key fields to Prisma relation syntax
-     * Handles common patterns like user_id -> creator, avatar_id -> avatar, etc.
-     */
-    convertForeignKeysToRelations(data) {
-        const processedData = { ...data };
-        const relationMappings = {
-            // Common relation mappings for foreign keys to relation names
-            'user_id': 'creator',
-            'avatar_id': 'avatar',
-            'file_id': 'logo',
-            'company_id': 'company',
-            'user_group_id': 'userGroup',
-            'accountGrade_id': 'accountGrade',
-            'account_balance_id': 'accountBalance',
-            'knowledgeGroup_id': 'project',
-            'conversation_id': 'conversation',
-            'message_id': 'message',
-            'knowledge_id': 'knowledge',
-            'profession_id': 'profession',
-            'step_id': 'step',
-            'question_id': 'question',
-            'tutorial_id': 'tutorial',
-            'tutorial_step_id': 'tutorialStep',
-            'tutorial_section_id': 'tutorialSection',
-            'todo_id': 'todo',
-            'bot_test_id': 'botTest',
-            'bot_test_tester_id': 'tester',
-            'bot_test_target_id': 'target',
-            'branch_id': 'branch',
-            'acl_policy_id': 'policy',
-            'instruction_file_id': 'instructionFile'
-        };
-        // Convert foreign key fields to relation syntax
-        Object.keys(processedData).forEach(key => {
-            if (key.endsWith('_id') && relationMappings[key]) {
-                const relationField = relationMappings[key];
-                const value = processedData[key];
-                // Remove the foreign key field
-                delete processedData[key];
-                // Add the relation field with proper Prisma syntax
-                if (value === null || value === undefined) {
-                    processedData[relationField] = { disconnect: true };
-                }
-                else {
-                    processedData[relationField] = { connect: { id: value } };
-                }
-            }
-        });
-        return processedData;
-    }
     getPrismaClient() {
         if (!this.client || !this.connected) {
             this.connectToDB();

package/package.json

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

package/src/decorators/InverseRelation.ts

@@ -9,6 +9,7 @@ export interface InverseRelationOpts {
     singular?: boolean
     relationName?: string
     mappingName?: string
+    orderBy?: { [field: string]: 'asc' | 'desc' }
 }
 
 function guessForeignKey(inversionModel: OpModelType<RWSModel<any>>, bindingModel: OpModelType<RWSModel<any>>, decoratorsData: any)

package/src/models/core/RWSModel.ts

@@ -33,6 +33,18 @@ class RWSModel<T> implements IModel {
 
     private postLoadExecuted: boolean = false;
 
+    /**
+     * Store relation foreign key fields for later hydration
+     */
+    private storeRelationFields(data: any, relOneData: any): void {
+        for (const relationName in relOneData) {
+            const relationMeta = relOneData[relationName];
+            if (relationMeta.hydrationField && data[relationMeta.hydrationField]) {
+                this._relationFields[relationMeta.hydrationField] = data[relationMeta.hydrationField];
+            }
+        }
+    }
+
     constructor(data: any = null) {    
         if(!this.getCollection()){
             throw new Error('Model must have a collection defined');
@@ -130,10 +142,20 @@ class RWSModel<T> implements IModel {
             collections_to_models[model.getCollection()] = model;      
         });      
     
-        const seriesHydrationfields: string[] = []; 
+        const seriesHydrationfields: string[] = [];
+        
+        // Always preprocess foreign keys to relation objects, even if allowRelations is false
+        // This is necessary because toMongo() expects relation objects to exist
+        try {
+            data = await HydrateUtils.preprocessForeignKeys(data, this, relOneData);
+        } catch (error) {
+            console.error('Error in preprocessForeignKeys:', error);
+            throw error;
+        }
 
         // 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
@@ -142,15 +164,24 @@ class RWSModel<T> implements IModel {
             // 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
+            // Create a copy of data without relation fields AND foreign key fields to prevent conflicts
             const dataWithoutRelations = { ...data };
             for (const key in relOneData) {
-                delete dataWithoutRelations[key];
+                delete dataWithoutRelations[key]; // Remove relation field (e.g., 'screenFile')
+                
+                const relationMeta = relOneData[key];
+                if (relationMeta.hydrationField) {
+                    delete dataWithoutRelations[relationMeta.hydrationField]; // Remove foreign key field (e.g., 'screen_file_id')
+                }
             }
             for (const key in relManyData) {
-                delete dataWithoutRelations[key];
+                delete dataWithoutRelations[key]; // Remove relation array fields
             }
             data = dataWithoutRelations;
+        } else {
+            // Even if relations are disabled, we still need to store relation foreign key fields
+            // for later hydration when reload() is called
+            this.storeRelationFields(data, relOneData);
         }
     
         // Process regular fields and time series (excluding relations when pre-populated)
@@ -195,6 +226,7 @@ class RWSModel<T> implements IModel {
     }
 
     public async toMongo(): Promise<any> {
+        
         const data: any = {};
         const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(this);
         const timeSeriesHydrationFields: string[] = [];
@@ -202,33 +234,33 @@ class RWSModel<T> implements IModel {
         // Get relation metadata to determine how to handle each relation
         const classFields = FieldsHelper.getAllClassFields(this.constructor);
         const relOneData = await this.getRelationOneMeta(classFields);
-      
+        
+        // Check if this is a new model (no ID) to handle relations differently during creation
+        const isNewModel = !this.id;
+        
         for (const key in (this as any)) { 
+            
             if (await this.hasRelation(key)) {
                 const relationMeta = relOneData[key];
                 
                 if (relationMeta) {
-                    // Use connect on relations that are either:
-                    // 1. Required (required: true)
-                    // 2. Have explicitly set cascade options (metaOpts.cascade)
-                    const hasExplicitCascade = relationMeta.cascade && Object.keys(relationMeta.cascade).length > 0;
-                    const shouldUseConnect = relationMeta.required || hasExplicitCascade;
                     
-                    if (shouldUseConnect) {
-                        // Relations with required=true or explicit cascade → use connect
-                        if (this[key] === null) {
+                    // Always use Prisma relation syntax when relation objects exist
+                    // This ensures compatibility with Prisma's expected format
+                    
+                    if (this[key] === null || this[key] === undefined) {
+                        // Only add disconnect if this is an update (not a creation)
+                        if (!isNewModel) {
                             data[key] = { disconnect: true };
-                        } else if (this[key] && this[key].id) {
-                            data[key] = { connect: { id: this[key].id } };                            
-                        }
-                    } else {
-                        // Simple optional relations → use foreign key field directly
-                        const foreignKeyField = relationMeta.hydrationField;
-                        if (this[key] === null) {
-                            data[foreignKeyField] = null;
-                        } else if (this[key] && this[key].id) {
-                            data[foreignKeyField] = this[key].id;
                         }
+                        // For new models, we simply don't include the relation field
+                    } else if (this[key] && this[key].id) {
+                        data[key] = { connect: { id: this[key].id } };
+                    } else if (this[key] && typeof this[key] === 'object' && !this[key].id) {
+                        // Handle case where we have a relation object but it might not have an ID yet
+                        // This could happen if the relation object is also being created
+                        // In this case, we might want to create the relation first or handle it differently
+                        console.warn(`Relation ${key} has an object without ID. This might cause issues during creation.`);
                     }
                 }
                 
@@ -256,7 +288,7 @@ class RWSModel<T> implements IModel {
                 timeSeriesHydrationFields.push(timeSeriesIds[key].hydrationField);              
             }
         }               
-            
+        
         return data;
     }  
 
@@ -268,8 +300,9 @@ class RWSModel<T> implements IModel {
         return (this as any).constructor._collection || this._collection;
     }
 
-    async save(): Promise<this> {
+    async save(): Promise<this> {        
         const data = await this.toMongo();
+        
         let updatedModelData = data;  
 
         const entryExists = await ModelUtils.entryExists(this);        
@@ -495,7 +528,15 @@ class RWSModel<T> implements IModel {
         // Add one-to-many relations (without nesting)
         for (const key in relManyData) {
             if (shouldIncludeRelation(key)) {
-                includes[key] = true; // Only load this level, no nested relations
+                const relationMeta = relManyData[key];
+                if (relationMeta.orderBy) {
+                    // Add Prisma orderBy to the relation include
+                    includes[key] = {
+                        orderBy: relationMeta.orderBy
+                    };
+                } else {
+                    includes[key] = true; // Only load this level, no nested relations
+                }
             }
         }
         

package/src/models/types/RelationTypes.ts

@@ -25,6 +25,7 @@ export type RelManyMetaType<T extends IRWSModel> = {
         key: string, 
         inversionModel: OpModelType<T>, 
         foreignKey: string,
-        singular: boolean
+        singular: boolean,
+        orderBy?: { [field: string]: 'asc' | 'desc' }
     }
 };

package/src/models/utils/HydrateUtils.ts

@@ -9,7 +9,52 @@ import { FieldsHelper } from "../../helper/FieldsHelper";
 import chalk from 'chalk';
 
 export class HydrateUtils {
+    /**
+     * Preprocess database data to convert foreign keys to relation objects when relations are not already populated
+     */
+    static async preprocessForeignKeys(data: any, model: RWSModel<any>, relOneData: RelOneMetaType<IRWSModel>): Promise<any> {
+        const processedData = { ...data };
+        
+        // For each relation, handle different scenarios during creation and updates
+        for (const relationName in relOneData) {
+            const relationMeta = relOneData[relationName];
+            const foreignKeyField = relationMeta.hydrationField; // e.g., "tutorial_id"
+            const relationField = relationMeta.key; // e.g., "tutorial"
+            
+            // Scenario 1: We have a foreign key value but no relation object (or the relation is just an ID)
+            if (foreignKeyField in data && data[foreignKeyField] !== null && data[foreignKeyField] !== undefined && 
+                (!data[relationField] || typeof data[relationField] !== 'object')) {
+                
+                // Create a minimal relation object with just the ID
+                // This allows toMongo() to work properly without requiring full relation loading
+                processedData[relationField] = { id: data[foreignKeyField] };
+            }
+            
+            // Scenario 2: We have a relation object but no foreign key field (common during creation)
+            // Ensure the foreign key field exists when we have a valid relation object
+            else if (data[relationField] && typeof data[relationField] === 'object' && 
+                     data[relationField].id && 
+                     (!(foreignKeyField in data) || data[foreignKeyField] === null || data[foreignKeyField] === undefined)) {
+                
+                // Set the foreign key field from the relation object's ID
+                processedData[foreignKeyField] = data[relationField].id;
+            }
+            
+            // Scenario 3: Both relation object and foreign key exist, ensure they're consistent
+            else if (data[relationField] && typeof data[relationField] === 'object' && 
+                     data[relationField].id && foreignKeyField in data && 
+                     data[foreignKeyField] !== data[relationField].id) {
+                
+                // Prioritize the relation object's ID
+                processedData[foreignKeyField] = data[relationField].id;
+            }
+        }
+        
+        return processedData;
+    }
+    
     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
@@ -26,6 +71,7 @@ export class HydrateUtils {
         
         for (const key in data) {
             if (data.hasOwnProperty(key)) {
+                
                 if (!fullDataMode && ignoredKeys.includes(key)) {
                     continue;
                 }
@@ -117,9 +163,13 @@ export class HydrateUtils {
             const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
 
             if (!data[relMeta.hydrationField] && relMeta.required) {
-                // Only throw error if this is a fresh load, not a reload of existing model
-                if (!model.id) {
-                    throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${model.constructor.name}.`);
+                // Only throw error if this is a fresh load AND we're not in creation mode
+                // During creation, required relations might not have their foreign key set yet
+                if (!model.id && data[relMeta.key]) {
+                    // We have the relation object but not the foreign key - this is okay during creation
+                    continue;
+                } else if (!model.id && !data[relMeta.key]) {
+                    throw new Error(`Required relation "${relMeta.key}" is missing in model ${model.constructor.name}.`);
                 }
                 // For existing models (reloads), skip loading this relation if the field is missing
                 continue;

package/src/models/utils/RelationUtils.ts

@@ -51,7 +51,8 @@ export class RelationUtils {
                         key: resolvedMetadata.key,         
                         inversionModel: resolvedMetadata.inversionModel,
                         foreignKey: resolvedMetadata.foreignKey,     
-                        singular: resolvedMetadata?.singular || false             
+                        singular: resolvedMetadata?.singular || false,
+                        orderBy: resolvedMetadata?.orderBy || null
                     };
                 }
             }                         

package/src/services/DBService.ts

@@ -1,15 +1,16 @@
 import { PrismaClient } from '@prisma/client';
 import { Collection, Db, MongoClient } from 'mongodb';
-import {ITimeSeries} from '../types/ITimeSeries';
+import { ITimeSeries } from '../types/ITimeSeries';
 import { IModel } from '../models/interfaces/IModel';
 import chalk from 'chalk';
 import { IDbConfigHandler } from '../types/DbConfigHandler';
 import { IPaginationParams, OrderByType, OrderByField, OrderByArray } from '../types/FindParams';
 import { OpModelType } from '../models/interfaces/OpModelType';
+import { ModelUtils } from '../models/utils/ModelUtils';
 
 interface IDBClientCreate {
-  dbUrl?: string;
-  dbName?: string;
+    dbUrl?: string;
+    dbName?: string;
 }
 
 class DBService {
@@ -17,66 +18,62 @@ class DBService {
     private opts: IDBClientCreate = null;
     private connected = false;
 
-    constructor(private configService: IDbConfigHandler){}
+    constructor(private configService: IDbConfigHandler) { }
 
     private connectToDB(opts: IDBClientCreate = null) {
-        if(opts){
+        if (opts) {
             this.opts = opts;
-        }else{
+        } else {
             this.opts = {
-                dbUrl: this.configService.get('db_url'),        
+                dbUrl: this.configService.get('db_url'),
                 dbName: this.configService.get('db_name'),
             };
         }
 
-        if(!this.opts.dbUrl){
+        if (!this.opts.dbUrl) {
             console.log(chalk.red('No database config set in @rws-framework/db'));
 
             return;
-        }    
-  
-        try{
-            this.client = new PrismaClient({ 
+        }
+
+        try {
+            this.client = new PrismaClient({
                 datasources: {
                     db: {
                         url: this.opts.dbUrl
                     },
                 },
-            });     
+            });
 
             this.connected = true;
-        } catch (e: Error | any){                        
+        } catch (e: Error | any) {
             console.error(e);
-        
+
             throw new Error('PRISMA CONNECTION ERROR');
         }
     }
 
-    reconnect(opts: IDBClientCreate = null)
-    {
+    reconnect(opts: IDBClientCreate = null) {
         this.connectToDB(opts);
     }
 
-    static baseClientConstruct(dbUrl: string): MongoClient
-    {        
+    static baseClientConstruct(dbUrl: string): MongoClient {
         const client = new MongoClient(dbUrl);
 
         return client;
     }
 
-    public async createBaseMongoClient(): Promise<MongoClient>
-    {
+    public async createBaseMongoClient(): Promise<MongoClient> {
         const dbUrl = this.opts?.dbUrl || this.configService.get('db_url');
         const client = DBService.baseClientConstruct(dbUrl);
-    
+
         await client.connect();
 
         return client;
 
     }
 
-    public async createBaseMongoClientDB(): Promise<[MongoClient, Db]>
-    {
+    public async createBaseMongoClientDB(): Promise<[MongoClient, Db]> {
         const dbName = this.opts?.dbName || this.configService.get('db_name');
         const client = await this.createBaseMongoClient();
         return [client, client.db(dbName)];
@@ -101,104 +98,98 @@ class DBService {
         await client.close();
     }
 
-    async watchCollection(collectionName: string, preRun: () => void): Promise<any>
-    {    
+    async watchCollection(collectionName: string, preRun: () => void): Promise<any> {
         const [client, db] = await this.createBaseMongoClientDB();
         const collection = db.collection(collectionName);
 
-        const changeStream = collection.watch();    
-        return new Promise((resolve) => {      
-            changeStream.on('change', (change) => {           
+        const changeStream = collection.watch();
+        return new Promise((resolve) => {
+            changeStream.on('change', (change) => {
                 resolve(change);
             });
 
             preRun();
-        });   
+        });
     }
 
     async insert(data: any, collection: string, isTimeSeries: boolean = false) {
-    
+
         let result: any = data;
         // Insert time-series data outside of the transaction
 
-        if(isTimeSeries){
+        if (isTimeSeries) {
             const [client, db] = await this.createBaseMongoClientDB();
             const collectionHandler = db.collection(collection);
-      
+
             const insert = await collectionHandler.insertOne(data);
 
-            result = await this.findOneBy(collection, { id: insert.insertedId.toString()  });
+            result = await this.findOneBy(collection, { id: insert.insertedId.toString() });
             return result;
         }
 
-        const prismaCollection = this.getCollectionHandler(collection);    
+        const prismaCollection = this.getCollectionHandler(collection);
 
         result = await prismaCollection.create({ data });
 
         return await this.findOneBy(collection, { id: result.id });
     }
 
-    async update(data: any, collection: string, pk: string | string[]): Promise<IModel> 
-    {        
+    async update(data: any, collection: string, pk: string | string[]): Promise<IModel> {
 
         const prismaCollection = this.getCollectionHandler(collection);
 
 
         const where: any = {};
-                    
-        if(Array.isArray(pk)){            
-            for(const pkElem of pk){
+
+        if (Array.isArray(pk)) {
+            for (const pkElem of pk) {
                 where[pkElem] = data[pkElem];
             }
-        }else{
+        } else {
             where[pk as string] = data[pk as string]
-        }         
+        }
 
-        if(!Array.isArray(pk)){
+        if (!Array.isArray(pk)) {
             delete data[pk];
-        }else{
-            for(const cKey in pk){
+        } else {
+            for (const cKey in pk) {
                 delete data[cKey];
             }
-        }        
-
-        // Convert foreign key fields to Prisma relation syntax
-        const processedData = this.convertForeignKeysToRelations(data);
+        }
 
         await prismaCollection.update({
             where,
-            data: processedData,
-        });    
+            data,
+        });
+
 
-        
         return await this.findOneBy(collection, where);
     }
-  
 
-    async findOneBy(collection: string, conditions: any, fields: string[] | null = null, ordering: OrderByType = null, prismaOptions: any = 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 };
 
-        if(fields){
+        if (fields) {
             params.select = {};
-            fields.forEach((fieldName: string) => {        
+            fields.forEach((fieldName: string) => {
                 params.select[fieldName] = true;
-            });    
-            
+            });
+
             // Add relation fields to select instead of using include when fields are specified
-            if(prismaOptions?.include) {
+            if (prismaOptions?.include) {
                 Object.keys(prismaOptions.include).forEach(relationField => {
                     if (fields.includes(relationField)) {
                         params.select[relationField] = true;
                     }
                 });
             }
-        } else if(prismaOptions?.include) {
+        } else if (prismaOptions?.include) {
             // Only use include when no fields are specified
             params.include = prismaOptions.include;
         }
 
-        if(ordering){
+        if (ordering) {
             params.orderBy = this.convertOrderingToPrismaFormat(ordering);
         }
 
@@ -207,63 +198,60 @@ class DBService {
         return retData;
     }
 
-    async delete(collection: string, conditions: any): Promise<void>
-    {    
+    async delete(collection: string, conditions: any): Promise<void> {
         await this.getCollectionHandler(collection).deleteMany({ where: conditions });
         return;
     }
 
     async findBy(
-        collection: string, 
-        conditions: any, 
-        fields: string[] | null = null, 
-        ordering: OrderByType = null, 
+        collection: string,
+        conditions: any,
+        fields: string[] | null = null,
+        ordering: OrderByType = null,
         pagination: IPaginationParams = null,
-        prismaOptions: any = null): Promise<IModel[]>
-    {    
-        const params: any ={ where: conditions };
+        prismaOptions: any = null): Promise<IModel[]> {
+        const params: any = { where: conditions };
 
-        if(fields){
+        if (fields) {
             params.select = {};
-            fields.forEach((fieldName: string) => {        
+            fields.forEach((fieldName: string) => {
                 params.select[fieldName] = true;
-            });    
-            
+            });
+
             // Add relation fields to select instead of using include when fields are specified
-            if(prismaOptions?.include) {
+            if (prismaOptions?.include) {
                 Object.keys(prismaOptions.include).forEach(relationField => {
                     if (fields.includes(relationField)) {
                         params.select[relationField] = true;
                     }
                 });
             }
-        } else if(prismaOptions?.include) {
+        } else if (prismaOptions?.include) {
             // Only use include when no fields are specified
             params.include = prismaOptions.include;
         }
 
-        if(ordering){
+        if (ordering) {
             params.orderBy = this.convertOrderingToPrismaFormat(ordering);
-        }    
+        }
 
-        if(pagination){
+        if (pagination) {
             const perPage = pagination.per_page || 50;
             params.skip = (pagination.page || 0) * perPage;
             params.take = perPage;
         }
 
-        const retData = await this.getCollectionHandler(collection).findMany(params);        
+        const retData = await this.getCollectionHandler(collection).findMany(params);
 
         return retData;
     }
 
-    async collectionExists(collection_name: string): Promise<boolean>
-    {
+    async collectionExists(collection_name: string): Promise<boolean> {
         const dbUrl = this.opts?.dbUrl || this.configService.get('db_url');
         const client = new MongoClient(dbUrl);
 
         try {
-            await client.connect();    
+            await client.connect();
 
             const db = client.db(this.configService.get('db_name'));
 
@@ -275,12 +263,11 @@ class DBService {
             console.error('Error connecting to MongoDB:', error);
 
             throw error;
-        }    
+        }
     }
 
-    async createTimeSeriesCollection(collection_name: string): Promise<Collection<ITimeSeries>>
-    {    
-        try {    
+    async createTimeSeriesCollection(collection_name: string): Promise<Collection<ITimeSeries>> {
+        try {
             const [client, db] = await this.createBaseMongoClientDB();
 
             // Create a time series collection
@@ -302,9 +289,8 @@ class DBService {
         }
     }
 
-    private getCollectionHandler(collection: string): any 
-    {    
-        if(!this.client || !this.connected){
+    private getCollectionHandler(collection: string): any {
+        if (!this.client || !this.connected) {
             this.connectToDB();
         }
 
@@ -325,74 +311,17 @@ class DBService {
         return [ordering];
     }
 
-    private setOpts(opts: IDBClientCreate = null): this
-    {    
+    private setOpts(opts: IDBClientCreate = null): this {
         this.opts = opts;
         return this;
     }
 
-    public async count<T = any>(opModel: OpModelType<T>, where: {[k: string]: any} = {}): Promise<number>{        
-        return await this.getCollectionHandler(opModel._collection).count({where});
-    }
-
-    /**
-     * Convert foreign key fields to Prisma relation syntax
-     * Handles common patterns like user_id -> creator, avatar_id -> avatar, etc.
-     */
-    private convertForeignKeysToRelations(data: any): any {
-        const processedData = { ...data };
-        const relationMappings: { [key: string]: string } = {
-            // Common relation mappings for foreign keys to relation names
-            'user_id': 'creator',
-            'avatar_id': 'avatar',
-            'file_id': 'logo',
-            'company_id': 'company',
-            'user_group_id': 'userGroup',
-            'accountGrade_id': 'accountGrade',
-            'account_balance_id': 'accountBalance',
-            'knowledgeGroup_id': 'project',
-            'conversation_id': 'conversation',
-            'message_id': 'message',
-            'knowledge_id': 'knowledge',
-            'profession_id': 'profession',
-            'step_id': 'step',
-            'question_id': 'question',
-            'tutorial_id': 'tutorial',
-            'tutorial_step_id': 'tutorialStep',
-            'tutorial_section_id': 'tutorialSection',
-            'todo_id': 'todo',
-            'bot_test_id': 'botTest',
-            'bot_test_tester_id': 'tester',
-            'bot_test_target_id': 'target',
-            'branch_id': 'branch',
-            'acl_policy_id': 'policy',
-            'instruction_file_id': 'instructionFile'
-        };
-
-        // Convert foreign key fields to relation syntax
-        Object.keys(processedData).forEach(key => {
-            if (key.endsWith('_id') && relationMappings[key]) {
-                const relationField = relationMappings[key];
-                const value = processedData[key];
-                
-                // Remove the foreign key field
-                delete processedData[key];
-                
-                // Add the relation field with proper Prisma syntax
-                if (value === null || value === undefined) {
-                    processedData[relationField] = { disconnect: true };
-                } else {
-                    processedData[relationField] = { connect: { id: value } };
-                }
-            }
-        });
-
-        return processedData;
+    public async count<T = any>(opModel: OpModelType<T>, where: { [k: string]: any } = {}): Promise<number> {
+        return await this.getCollectionHandler(opModel._collection).count({ where });
     }
 
-    public getPrismaClient(): PrismaClient
-    {
-        if(!this.client || !this.connected){
+    public getPrismaClient(): PrismaClient {
+        if (!this.client || !this.connected) {
             this.connectToDB();
         }