@rws-framework/db 3.7.0 → 3.7.2

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

@@ -25,6 +25,7 @@ declare class RWSModel<T> implements IModel {
     static checkForInclusion(this: OpModelType<any>, checkModelType: string): boolean;
     protected _fill(data: any): RWSModel<T>;
     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

@@ -89,6 +89,9 @@ class RWSModel {
     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);
     }
@@ -140,6 +143,13 @@ class RWSModel {
         for (const key in this) {
             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

@@ -10,5 +10,6 @@ export declare class RelationUtils {
         };
     } | 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

@@ -49,7 +49,7 @@ class RelationUtils {
         return relIds;
     }
     static bindRelation(relatedModel) {
-        if (!relatedModel.id) {
+        if (!relatedModel || !relatedModel.id) {
             return null;
         }
         return {
@@ -66,6 +66,18 @@ class RelationUtils {
             .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;
         let declaredRelations = [];

package/dist/services/DBService.d.ts

@@ -1,3 +1,4 @@
+import { PrismaClient } from '@prisma/client';
 import { Collection, Db, MongoClient } from 'mongodb';
 import { ITimeSeries } from '../types/ITimeSeries';
 import { IModel } from '../models/interfaces/IModel';
@@ -37,5 +38,6 @@ declare class DBService {
     count<T = any>(opModel: OpModelType<T>, where?: {
         [k: string]: any;
     }): Promise<number>;
+    getPrismaClient(): PrismaClient;
 }
 export { DBService, IDBClientCreate };

package/dist/services/DBService.js

@@ -209,5 +209,11 @@ class DBService {
     async count(opModel, where = {}) {
         return await this.getCollectionHandler(opModel._collection).count({ where });
     }
+    getPrismaClient() {
+        if (!this.client || !this.connected) {
+            this.connectToDB();
+        }
+        return this.client;
+    }
 }
 exports.DBService = DBService;

package/package.json

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

package/src/models/core/RWSModel.ts

@@ -105,6 +105,10 @@ class RWSModel<T> implements IModel {
         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);
     }
@@ -178,7 +182,15 @@ class RWSModel<T> implements IModel {
       
         for (const key in (this as any)) { 
             if (await this.hasRelation(key)) {                
-                data[key] = this.bindRelation(key, this[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;
             }
     

package/src/models/utils/RelationUtils.ts

@@ -2,6 +2,7 @@ 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>> {
@@ -58,8 +59,8 @@ export class RelationUtils {
         return relIds;
     }
 
-    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string | number } } | null {
-        if(!relatedModel.id){
+    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string | number } } | null {    
+        if(!relatedModel || !relatedModel.id){
             return null;
         }
 
@@ -82,6 +83,24 @@ export class RelationUtils {
         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 {
         const constructor = model.constructor as OpModelType<any>;
 

package/src/services/DBService.ts

@@ -292,6 +292,15 @@ class DBService {
     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){
+            this.connectToDB();
+        }
+
+        return this.client;
+    }
 }
 
 export { DBService, IDBClientCreate };