@rws-framework/db 2.4.6 → 3.0.1

package/src/models/utils/RelationUtils.ts

@@ -1,76 +1,76 @@
-import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
-import { IRWSModel } from '../../types/IRWSModel';
-import { RWSModel } from '../_model';
-
-export class RelationUtils {
-    static async getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>> {
-        const relIds: RelOneMetaType<IRWSModel> = {};
-        const relationFields = classFields
-            .filter((item: string) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
-            .map((item: string) => item.split(':').at(-1));        
-    
-        for (const key of relationFields) {  
-            const metadataKey = `Relation:${key}`;
-            const metadata = Reflect.getMetadata(metadataKey, model);                 
-            
-            if (metadata && metadata.promise) {
-                const resolvedMetadata = await metadata.promise;
-                if (!relIds[key]) {
-                    relIds[key] = {
-                        key: resolvedMetadata.key,
-                        required: resolvedMetadata.required,
-                        model: resolvedMetadata.relatedTo,
-                        hydrationField: resolvedMetadata.relationField,
-                        foreignKey: resolvedMetadata.relatedToField
-                    };
-                }
-            }                         
-        } 
-    
-        return relIds;
-    }
-
-    static async getRelationManyMeta(model: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>> {
-        const relIds: RelManyMetaType<IRWSModel> = {};
-    
-        const inverseFields = classFields
-            .filter((item: string) => item.indexOf('InverseRelation') === 0)
-            .map((item: string) => item.split(':').at(-1));
-                
-        for (const key of inverseFields) {          
-            const metadataKey = `InverseRelation:${key}`;
-            const metadata = Reflect.getMetadata(metadataKey, model);                            
-    
-            if (metadata && metadata.promise) {
-                const resolvedMetadata = await metadata.promise;
-                if (!relIds[key]) {
-                    relIds[key] = {       
-                        key: resolvedMetadata.key,         
-                        inversionModel: resolvedMetadata.inversionModel,
-                        foreignKey: resolvedMetadata.foreignKey                   
-                    };
-                }
-            }                         
-        } 
-    
-        return relIds;
-    }
-
-    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string | number } } {
-        return {
-            connect: {
-                id: relatedModel.id
-            }
-        };
-    }
-
-    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 checkRelEnabled(model: RWSModel<any>, key: string): boolean {
-        return Object.keys((model.constructor as any)._RELATIONS).includes(key) && 
-               (model.constructor as any)._RELATIONS[key] === true;
-    }
-}
+import { RelOneMetaType, RelManyMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { RWSModel } from '../_model';
+
+export class RelationUtils {
+    static async getRelationOneMeta(model: RWSModel<any>, classFields: string[]): Promise<RelOneMetaType<IRWSModel>> {
+        const relIds: RelOneMetaType<IRWSModel> = {};
+        const relationFields = classFields
+            .filter((item: string) => item.indexOf('Relation') === 0 && !item.includes('Inverse'))
+            .map((item: string) => item.split(':').at(-1));        
+    
+        for (const key of relationFields) {  
+            const metadataKey = `Relation:${key}`;
+            const metadata = Reflect.getMetadata(metadataKey, model);                 
+            
+            if (metadata && metadata.promise) {
+                const resolvedMetadata = await metadata.promise;
+                if (!relIds[key]) {
+                    relIds[key] = {
+                        key: resolvedMetadata.key,
+                        required: resolvedMetadata.required,
+                        model: resolvedMetadata.relatedTo,
+                        hydrationField: resolvedMetadata.relationField,
+                        foreignKey: resolvedMetadata.relatedToField
+                    };
+                }
+            }                         
+        } 
+    
+        return relIds;
+    }
+
+    static async getRelationManyMeta(model: RWSModel<any>, classFields: string[]): Promise<RelManyMetaType<IRWSModel>> {
+        const relIds: RelManyMetaType<IRWSModel> = {};
+    
+        const inverseFields = classFields
+            .filter((item: string) => item.indexOf('InverseRelation') === 0)
+            .map((item: string) => item.split(':').at(-1));
+                
+        for (const key of inverseFields) {          
+            const metadataKey = `InverseRelation:${key}`;
+            const metadata = Reflect.getMetadata(metadataKey, model);                            
+    
+            if (metadata && metadata.promise) {
+                const resolvedMetadata = await metadata.promise;
+                if (!relIds[key]) {
+                    relIds[key] = {       
+                        key: resolvedMetadata.key,         
+                        inversionModel: resolvedMetadata.inversionModel,
+                        foreignKey: resolvedMetadata.foreignKey                   
+                    };
+                }
+            }                         
+        } 
+    
+        return relIds;
+    }
+
+    static bindRelation(relatedModel: RWSModel<any>): { connect: { id: string | number } } {
+        return {
+            connect: {
+                id: relatedModel.id
+            }
+        };
+    }
+
+    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 checkRelDisabled(model: RWSModel<any>, key: string): boolean {
+        return Object.keys((model.constructor as any)._RELATIONS).includes(key) && 
+               (model.constructor as any)._RELATIONS[key] === false;
+    }
+}

package/src/models/utils/TimeSeriesUtils.ts

@@ -1,38 +1,38 @@
-import { RWSModel } from "../_model";
-
-export class TimeSeriesUtils {
-    static getTimeSeriesModelFields(model: RWSModel<any>): {[key: string]: {collection: string, hydrationField: string, ids: string[]}} {
-        const timeSeriesIds: {[key: string]: {collection: string, hydrationField: string, ids: string[]}} = {};
-
-        for (const key in model) {
-            if (model.hasOwnProperty(key)) {             
-                const meta = Reflect.getMetadata(`InverseTimeSeries:${key}`, model);            
-                if(meta){
-                    if(!timeSeriesIds[key]){
-                        timeSeriesIds[key] = {
-                            collection: meta.timeSeriesModel,
-                            hydrationField: meta.hydrationField,
-                            ids: model[key]
-                        };
-                    }
-                }                         
-            }
-        } 
-
-        return timeSeriesIds;
-    }
-
-    static checkTimeSeries(constructor: any): boolean {            
-        const data = constructor.prototype as any;
-
-        for (const key in data) {
-            if (data.hasOwnProperty(key)) {   
-                if(Reflect.getMetadata(`InverseTimeSeries:${key}`, constructor.prototype)){
-                    return true;
-                }
-            }
-        }
-
-        return false;
-    }
-}
+import { RWSModel } from "../_model";
+
+export class TimeSeriesUtils {
+    static getTimeSeriesModelFields(model: RWSModel<any>): {[key: string]: {collection: string, hydrationField: string, ids: string[]}} {
+        const timeSeriesIds: {[key: string]: {collection: string, hydrationField: string, ids: string[]}} = {};
+
+        for (const key in model) {
+            if (model.hasOwnProperty(key)) {             
+                const meta = Reflect.getMetadata(`InverseTimeSeries:${key}`, model);            
+                if(meta){
+                    if(!timeSeriesIds[key]){
+                        timeSeriesIds[key] = {
+                            collection: meta.timeSeriesModel,
+                            hydrationField: meta.hydrationField,
+                            ids: model[key]
+                        };
+                    }
+                }                         
+            }
+        } 
+
+        return timeSeriesIds;
+    }
+
+    static checkTimeSeries(constructor: any): boolean {            
+        const data = constructor.prototype as any;
+
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {   
+                if(Reflect.getMetadata(`InverseTimeSeries:${key}`, constructor.prototype)){
+                    return true;
+                }
+            }
+        }
+
+        return false;
+    }
+}