@rws-framework/db 3.10.1 → 3.11.1

package/dist/index.d.ts

@@ -3,10 +3,10 @@ import { RWSModel, OpModelType } from "./models/_model";
 import { InverseRelation, Relation, TrackType, IdType, InverseTimeSeries, ITrackerMetaOpts, ITrackerOpts } from './decorators';
 import { DbHelper } from './helper/DbHelper';
 import { FieldsHelper } from './helper/FieldsHelper';
-import type { FindByType } from './types/FindParams';
+import type { FindByType, OrderByType, OrderByField, OrderByArray, SortDirection } from './types/FindParams';
 import type { ITimeSeries } from './types/ITimeSeries';
 import type { IDbConfigHandler, IDbConfigParams } from './types/DbConfigHandler';
 import type { IRWSModel } from './types/IRWSModel';
 import { RWSCollection, IRWSCollectionMeta, IRWSCollectionOpts } from "./decorators/RWSCollection";
-export type { IRWSCollectionMeta, IRWSCollectionOpts, IRWSModel, ITrackerMetaOpts, ITrackerOpts, OpModelType, IDbConfigHandler, IDbConfigParams, ITimeSeries, };
+export type { IRWSCollectionMeta, IRWSCollectionOpts, IRWSModel, ITrackerMetaOpts, ITrackerOpts, OpModelType, IDbConfigHandler, IDbConfigParams, ITimeSeries, OrderByType, OrderByField, OrderByArray, SortDirection };
 export { RWSModel, RWSCollection, DBService, FindByType, InverseRelation, Relation, TrackType, InverseTimeSeries, IdType, DbHelper, FieldsHelper };

package/dist/models/core/RWSModel.js

@@ -140,18 +140,38 @@ class RWSModel {
         const data = {};
         const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(this);
         const timeSeriesHydrationFields = [];
+        // Get relation metadata to determine how to handle each relation
+        const classFields = FieldsHelper_1.FieldsHelper.getAllClassFields(this.constructor);
+        const relOneData = await this.getRelationOneMeta(classFields);
         for (const key in this) {
             if (await this.hasRelation(key)) {
-                if (this[key] === null) {
-                    // For null relations, use disconnect or set to null
-                    data[key] = {
-                        disconnect: true
-                    };
-                }
-                else {
-                    data[key] = this.bindRelation(key, this[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) {
+                            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;
+                        }
+                    }
                 }
-                // Don't try to set the foreign key directly anymore
                 continue;
             }
             if (!(await this.isDbVariable(key))) {

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

@@ -12,6 +12,10 @@ export type RelOneMetaType<T extends IRWSModel> = {
         model: OpModelType<T>;
         hydrationField: string;
         foreignKey: string;
+        cascade?: {
+            onDelete?: string;
+            onUpdate?: string;
+        };
     };
 };
 export type RelManyMetaType<T extends IRWSModel> = {

package/dist/models/utils/RelationUtils.js

@@ -19,7 +19,8 @@ class RelationUtils {
                         required: resolvedMetadata.required,
                         model: resolvedMetadata.relatedTo,
                         hydrationField: resolvedMetadata.relationField,
-                        foreignKey: resolvedMetadata.relatedToField
+                        foreignKey: resolvedMetadata.relatedToField,
+                        cascade: resolvedMetadata.cascade
                     };
                 }
             }

package/dist/services/DBService.d.ts

@@ -3,7 +3,7 @@ import { Collection, Db, MongoClient } from 'mongodb';
 import { ITimeSeries } from '../types/ITimeSeries';
 import { IModel } from '../models/interfaces/IModel';
 import { IDbConfigHandler } from '../types/DbConfigHandler';
-import { IPaginationParams } from '../types/FindParams';
+import { IPaginationParams, OrderByType } from '../types/FindParams';
 import { OpModelType } from '../models/interfaces/OpModelType';
 interface IDBClientCreate {
     dbUrl?: string;
@@ -24,16 +24,13 @@ 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?: {
-        [fieldName: string]: string;
-    }): Promise<IModel | null>;
+    findOneBy(collection: string, conditions: any, fields?: string[] | null, ordering?: OrderByType): Promise<IModel | null>;
     delete(collection: string, conditions: any): Promise<void>;
-    findBy(collection: string, conditions: any, fields?: string[] | null, ordering?: {
-        [fieldName: string]: string;
-    }, pagination?: IPaginationParams): Promise<IModel[]>;
+    findBy(collection: string, conditions: any, fields?: string[] | null, ordering?: OrderByType, pagination?: IPaginationParams): Promise<IModel[]>;
     collectionExists(collection_name: string): Promise<boolean>;
     createTimeSeriesCollection(collection_name: string): Promise<Collection<ITimeSeries>>;
     private getCollectionHandler;
+    private convertOrderingToPrismaFormat;
     private setOpts;
     count<T = any>(opModel: OpModelType<T>, where?: {
         [k: string]: any;

package/dist/services/DBService.js

@@ -135,7 +135,7 @@ class DBService {
             });
         }
         if (ordering) {
-            params.orderBy = ordering;
+            params.orderBy = this.convertOrderingToPrismaFormat(ordering);
         }
         const retData = await this.getCollectionHandler(collection).findFirst(params);
         return retData;
@@ -153,7 +153,7 @@ class DBService {
             });
         }
         if (ordering) {
-            params.orderBy = ordering;
+            params.orderBy = this.convertOrderingToPrismaFormat(ordering);
         }
         if (pagination) {
             const perPage = pagination.per_page || 50;
@@ -202,6 +202,17 @@ class DBService {
         }
         return this.client[collection];
     }
+    convertOrderingToPrismaFormat(ordering) {
+        if (!ordering) {
+            return null;
+        }
+        // If it's already an array, return as is (but handle null values for booleans)
+        if (Array.isArray(ordering)) {
+            return ordering;
+        }
+        // If it's a single object, convert to array format
+        return [ordering];
+    }
     setOpts(opts = null) {
         this.opts = opts;
         return this;

package/dist/types/FindParams.d.ts

@@ -1,8 +1,12 @@
+export type SortDirection = 'asc' | 'desc';
+export type OrderByField = {
+    [fieldName: string]: SortDirection;
+};
+export type OrderByArray = OrderByField[];
+export type OrderByType = OrderByField | OrderByArray;
 export type FindByType = {
     conditions?: any;
-    ordering?: {
-        [fieldName: string]: string;
-    };
+    ordering?: OrderByType;
     fields?: string[];
     allowRelations?: boolean;
     fullData?: boolean;

package/package.json

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

package/src/index.ts

@@ -14,7 +14,7 @@ import {
 import { DbHelper } from './helper/DbHelper';
 import { FieldsHelper } from './helper/FieldsHelper';
 
-import type  { FindByType } from './types/FindParams';
+import type  { FindByType, OrderByType, OrderByField, OrderByArray, SortDirection } from './types/FindParams';
 import type  { ITimeSeries } from './types/ITimeSeries';
 import type { IDbConfigHandler, IDbConfigParams } from './types/DbConfigHandler';
 import type { IRWSModel } from './types/IRWSModel';
@@ -29,6 +29,10 @@ export type {
    IDbConfigHandler,
    IDbConfigParams,
    ITimeSeries,
+   OrderByType,
+   OrderByField, 
+   OrderByArray,
+   SortDirection
 }
 
 export {       
@@ -37,7 +41,7 @@ export {
    
    DBService,
 
-   FindByType, 
+   FindByType,
    // TimeSeriesModel,   
 
    InverseRelation, Relation, TrackType, InverseTimeSeries, IdType,

package/src/models/core/RWSModel.ts

@@ -179,19 +179,40 @@ class RWSModel<T> implements IModel {
         const data: any = {};
         const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(this);
         const timeSeriesHydrationFields: string[] = [];
+        
+        // Get relation metadata to determine how to handle each relation
+        const classFields = FieldsHelper.getAllClassFields(this.constructor);
+        const relOneData = await this.getRelationOneMeta(classFields);
       
         for (const key in (this as any)) { 
-            if (await this.hasRelation(key)) {                
-                if (this[key] === null) {
-                    // For null relations, use disconnect or set to null
-                    data[key] = {
-                        disconnect: true
-                    };
-                } else {
-                    data[key] = this.bindRelation(key, this[key]);  
+            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) {
+                            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;
+                        }
+                    }
                 }
                 
-                // Don't try to set the foreign key directly anymore
                 continue;
             }
     

package/src/models/types/RelationTypes.ts

@@ -12,7 +12,11 @@ export type RelOneMetaType<T extends IRWSModel> = {
         key?: string, 
         model: OpModelType<T>, 
         hydrationField: string, 
-        foreignKey: string
+        foreignKey: string,
+        cascade?: {
+            onDelete?: string,
+            onUpdate?: string
+        }
     }
 };
 

package/src/models/utils/FindUtils.ts

@@ -5,7 +5,7 @@ import { TimeSeriesUtils } from "./TimeSeriesUtils";
 import { RelationUtils } from "./RelationUtils";
 import { OpModelType } from "..";
 import { ModelUtils } from "./ModelUtils";
-import { FindByType, IPaginationParams } from "../../types/FindParams";
+import { FindByType, IPaginationParams, OrderByType } from "../../types/FindParams";
 
 export class FindUtils {
     public static async findOneBy<T extends RWSModel<T>>(

package/src/models/utils/RelationUtils.ts

@@ -23,7 +23,8 @@ export class RelationUtils {
                         required: resolvedMetadata.required,
                         model: resolvedMetadata.relatedTo,
                         hydrationField: resolvedMetadata.relationField,
-                        foreignKey: resolvedMetadata.relatedToField
+                        foreignKey: resolvedMetadata.relatedToField,
+                        cascade: resolvedMetadata.cascade
                     };
                 }
             }                         

package/src/services/DBService.ts

@@ -4,7 +4,7 @@ import {ITimeSeries} from '../types/ITimeSeries';
 import { IModel } from '../models/interfaces/IModel';
 import chalk from 'chalk';
 import { IDbConfigHandler } from '../types/DbConfigHandler';
-import { IPaginationParams } from '../types/FindParams';
+import { IPaginationParams, OrderByType, OrderByField, OrderByArray } from '../types/FindParams';
 import { OpModelType } from '../models/interfaces/OpModelType';
 
 interface IDBClientCreate {
@@ -172,7 +172,7 @@ class DBService {
     }
   
 
-    async findOneBy(collection: string, conditions: any, fields: string[] | null = null, ordering: { [fieldName: string]: string } = null): Promise<IModel|null>
+    async findOneBy(collection: string, conditions: any, fields: string[] | null = null, ordering: OrderByType = null): Promise<IModel|null>
     {    
         const params: any = { where: conditions };
 
@@ -184,7 +184,7 @@ class DBService {
         }
 
         if(ordering){
-            params.orderBy = ordering;
+            params.orderBy = this.convertOrderingToPrismaFormat(ordering);
         }
 
         const retData = await this.getCollectionHandler(collection).findFirst(params);
@@ -202,7 +202,7 @@ class DBService {
         collection: string, 
         conditions: any, 
         fields: string[] | null = null, 
-        ordering: { [fieldName: string]: string } = null, 
+        ordering: OrderByType = null, 
         pagination: IPaginationParams = null): Promise<IModel[]>
     {    
         const params: any ={ where: conditions };
@@ -215,8 +215,8 @@ class DBService {
         }
 
         if(ordering){
-            params.orderBy = ordering;
-        }
+            params.orderBy = this.convertOrderingToPrismaFormat(ordering);
+        }    
 
         if(pagination){
             const perPage = pagination.per_page || 50;
@@ -283,6 +283,20 @@ class DBService {
         return (this.client[collection as keyof PrismaClient] as any);
     }
 
+    private convertOrderingToPrismaFormat(ordering: OrderByType): any {
+        if (!ordering) {
+            return null;
+        }
+
+        // If it's already an array, return as is (but handle null values for booleans)
+        if (Array.isArray(ordering)) {
+            return ordering;
+        }
+
+        // If it's a single object, convert to array format
+        return [ordering];
+    }
+
     private setOpts(opts: IDBClientCreate = null): this
     {    
         this.opts = opts;

package/src/types/FindParams.ts

@@ -1,6 +1,16 @@
+export type SortDirection = 'asc' | 'desc';
+
+export type OrderByField = {
+    [fieldName: string]: SortDirection;
+};
+
+export type OrderByArray = OrderByField[];
+
+export type OrderByType = OrderByField | OrderByArray;
+
 export type FindByType = {
     conditions?: any  
-    ordering?: { [fieldName: string]: string }
+    ordering?: OrderByType
     fields?: string[]
     allowRelations?: boolean
     fullData?: boolean