@rws-framework/db 3.6.1 → 3.7.1

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

@@ -24,7 +24,8 @@ declare class RWSModel<T> implements IModel {
     checkForInclusion(): boolean;
     static checkForInclusion(this: OpModelType<any>, checkModelType: string): boolean;
     protected _fill(data: any): RWSModel<T>;
-    protected hasRelation(key: string): boolean;
+    protected hasRelation(key: string): Promise<boolean>;
+    protected getRelationKey(key: string): Promise<string>;
     protected bindRelation(key: string, relatedModel: RWSModel<any>): {
         connect: {
             id: string | number;

package/dist/models/core/RWSModel.js

@@ -86,8 +86,11 @@ class RWSModel {
         }
         return this;
     }
-    hasRelation(key) {
-        return RelationUtils_1.RelationUtils.hasRelation(this, key);
+    async hasRelation(key) {
+        return RelationUtils_1.RelationUtils.hasRelation(this.constructor, key);
+    }
+    async getRelationKey(key) {
+        return RelationUtils_1.RelationUtils.getRelationKey(this.constructor, key);
     }
     bindRelation(key, relatedModel) {
         return RelationUtils_1.RelationUtils.bindRelation(relatedModel);
@@ -138,8 +141,15 @@ class RWSModel {
         const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(this);
         const timeSeriesHydrationFields = [];
         for (const key in this) {
-            if (this.hasRelation(key)) {
+            if (await this.hasRelation(key)) {
                 data[key] = this.bindRelation(key, this[key]);
+                if (data[key] === null) {
+                    const relationKey = await this.getRelationKey(key);
+                    if (relationKey) {
+                        data[relationKey] = null;
+                        delete data[key];
+                    }
+                }
                 continue;
             }
             if (!(await this.isDbVariable(key))) {

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

@@ -8,7 +8,8 @@ export declare class RelationUtils {
         connect: {
             id: string | number;
         };
-    };
-    static hasRelation(model: RWSModel<any>, key: string): boolean;
+    } | null;
+    static hasRelation(constructor: any, variable: string): Promise<boolean>;
+    static getRelationKey(constructor: any, variable: string): Promise<string | null>;
     static checkRelDisabled(model: RWSModel<any>, key: string): boolean;
 }

package/dist/models/utils/RelationUtils.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.RelationUtils = void 0;
+const ModelUtils_1 = require("./ModelUtils");
 class RelationUtils {
     static async getRelationOneMeta(model, classFields) {
         const relIds = {};
@@ -48,15 +49,34 @@ class RelationUtils {
         return relIds;
     }
     static bindRelation(relatedModel) {
+        if (!relatedModel || !relatedModel.id) {
+            return null;
+        }
         return {
             connect: {
                 id: relatedModel.id
             }
         };
     }
-    static hasRelation(model, key) {
-        // Check if the property exists and is an object with an id property
-        return !!model[key] && typeof model[key] === 'object' && model[key] !== null && 'id' in model[key];
+    static async hasRelation(constructor, variable) {
+        const dbAnnotations = await ModelUtils_1.ModelUtils.getModelAnnotations(constructor);
+        const dbProperties = Object.keys(dbAnnotations)
+            .map((key) => { return { ...dbAnnotations[key], key }; })
+            .filter((element) => element.annotationType === 'Relation')
+            .map((element) => element.key);
+        return dbProperties.includes(variable);
+    }
+    static async getRelationKey(constructor, variable) {
+        const dbAnnotations = await ModelUtils_1.ModelUtils.getModelAnnotations(constructor);
+        const relationMeta = Object.keys(dbAnnotations)
+            .map((key) => { return { ...dbAnnotations[key], key }; })
+            .filter((element) => element.annotationType === 'Relation')
+            .find((element) => element.key === variable);
+        ;
+        if (!relationMeta) {
+            return null;
+        }
+        return relationMeta.metadata.relationField;
     }
     static checkRelDisabled(model, key) {
         const constructor = model.constructor;

package/package.json

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

package/src/models/core/RWSModel.ts

@@ -101,10 +101,14 @@ class RWSModel<T> implements IModel {
         return this;
     }
 
-    protected hasRelation(key: string): boolean {
-        return RelationUtils.hasRelation(this, key);
+    protected async hasRelation(key: string): Promise<boolean> {
+        return RelationUtils.hasRelation((this as any).constructor, key);
     }
 
+    protected async getRelationKey(key: string): Promise<string> {
+        return RelationUtils.getRelationKey((this as any).constructor, key);
+    }   
+
     protected bindRelation(key: string, relatedModel: RWSModel<any>): { connect: { id: string | number } } {        
         return RelationUtils.bindRelation(relatedModel);
     }
@@ -177,8 +181,16 @@ class RWSModel<T> implements IModel {
         const timeSeriesHydrationFields: string[] = [];
       
         for (const key in (this as any)) { 
-            if (this.hasRelation(key)) {                
-                data[key] = this.bindRelation(key, this[key]);                
+            if (await this.hasRelation(key)) {                
+                data[key] = this.bindRelation(key, this[key]);  
+                
+                if(data[key] === null){
+                    const relationKey = await this.getRelationKey(key);
+                    if(relationKey){
+                        data[relationKey] = null;
+                        delete data[key];
+                    }
+                }            
                 continue;
             }
     
@@ -192,6 +204,7 @@ class RWSModel<T> implements IModel {
                 ).includes(key) && 
                 !timeSeriesHydrationFields.includes(key)
             ;
+
     
             if (passedFieldCondition) {                      
                 data[key] = this[key];
@@ -201,8 +214,8 @@ class RWSModel<T> implements IModel {
                 data[key] = this[key];
                 timeSeriesHydrationFields.push(timeSeriesIds[key].hydrationField);              
             }
-        }                
-    
+        }               
+            
         return data;
     }  
 

package/src/models/utils/RelationUtils.ts

@@ -1,6 +1,8 @@
 import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
 import { IRWSModel } from '../../types/IRWSModel';
 import { OpModelType, RWSModel } from '../_model';
+import { ModelUtils } from './ModelUtils';
+import { IRelationOpts } from 'src/decorators/Relation';
 
 export class RelationUtils {
     static async getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>> {
@@ -57,7 +59,11 @@ export class RelationUtils {
         return relIds;
     }
 
-    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string | number } } {
+    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string | number } } | null {    
+        if(!relatedModel || !relatedModel.id){
+            return null;
+        }
+
         return {
             connect: {
                 id: relatedModel.id
@@ -65,9 +71,34 @@ export class RelationUtils {
         };
     }
 
-    static hasRelation(model: RWSModel<any>, key: string): boolean {
-        // Check if the property exists and is an object with an id property
-        return !!model[key] && typeof model[key] === 'object' && model[key] !== null && 'id' in model[key];
+    static async hasRelation(constructor: any, variable: string): Promise<boolean> {
+        const dbAnnotations = await ModelUtils.getModelAnnotations(constructor);
+        type AnnotationType = { annotationType: string, key: string };
+    
+        const dbProperties: string[] = Object.keys(dbAnnotations)
+            .map((key: string): AnnotationType => {return {...dbAnnotations[key], key};})
+            .filter((element: AnnotationType) => element.annotationType === 'Relation' )
+            .map((element: AnnotationType) => element.key);
+    
+        return dbProperties.includes(variable);
+    }
+
+    static async getRelationKey(constructor: any, variable: string): Promise<string | null> {
+        const dbAnnotations = await ModelUtils.getModelAnnotations(constructor);
+        type AnnotationType = { annotationType: string, key: string };
+    
+        const relationMeta = Object.keys(dbAnnotations)
+            .map((key: string) => {return {...dbAnnotations[key], key};})
+            .filter((element: AnnotationType) => element.annotationType === 'Relation' )
+            .find((element: AnnotationType) => element.key === variable) as unknown as { metadata: IRelationOpts };
+        ;
+        
+
+        if(!relationMeta){
+            return null;
+        }
+    
+        return relationMeta.metadata.relationField;
     }
 
     static checkRelDisabled(model: RWSModel<any>, key: string): boolean {