@rws-framework/db 3.0.0 → 3.1.0

package/dist/models/interfaces/OpModelType.d.ts

@@ -21,7 +21,7 @@ export interface OpModelType<T> {
     checkForInclusionWithThrow: (className: string) => void;
     checkForInclusion: (className: string) => boolean;
     findOneBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T | null>;
-    find<T extends RWSModel<T>>(this: OpModelType<T>, id: string, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
+    find<T extends RWSModel<T>>(this: OpModelType<T>, id: string | number, findParams?: Omit<FindByType, 'conditions'>): Promise<T | null>;
     findBy<T extends RWSModel<T>>(this: OpModelType<T>, findParams?: FindByType): Promise<T[]>;
     paginate<T extends RWSModel<T>>(this: OpModelType<T>, paginateParams?: IPaginationParams, findParams?: FindByType): Promise<T[]>;
     delete<T extends RWSModel<T>>(this: OpModelType<T>, conditions: any): Promise<void>;

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

@@ -0,0 +1,13 @@
+import { RWSModel } from "../core/RWSModel";
+import { RelManyMetaType, RelOneMetaType } from "../types/RelationTypes";
+import { IRWSModel } from "../../types/IRWSModel";
+export declare class HydrateUtils {
+    static hydrateDataFields(model: RWSModel<any>, collections_to_models: {
+        [key: string]: any;
+    }, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {
+        [key: string]: any;
+    }): Promise<void>;
+    static hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {
+        [key: string]: any;
+    }): Promise<void>;
+}

package/dist/models/utils/HydrateUtils.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HydrateUtils = void 0;
+const TimeSeriesUtils_1 = require("./TimeSeriesUtils");
+const RelationUtils_1 = require("./RelationUtils");
+const ModelUtils_1 = require("./ModelUtils");
+class HydrateUtils {
+    static async hydrateDataFields(model, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data) {
+        const timeSeriesIds = TimeSeriesUtils_1.TimeSeriesUtils.getTimeSeriesModelFields(model);
+        for (const key in data) {
+            if (data.hasOwnProperty(key)) {
+                if (!fullDataMode && (model).constructor._CUT_KEYS.includes(key)) {
+                    continue;
+                }
+                if (Object.keys(relOneData).includes(key)) {
+                    continue;
+                }
+                if (seriesHydrationfields.includes(key)) {
+                    continue;
+                }
+                const timeSeriesMetaData = timeSeriesIds[key];
+                if (timeSeriesMetaData) {
+                    model[key] = data[key];
+                    const seriesModel = collections_to_models[timeSeriesMetaData.collection];
+                    const dataModels = await seriesModel.findBy({
+                        id: { in: data[key] }
+                    });
+                    seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
+                    model[timeSeriesMetaData.hydrationField] = dataModels;
+                }
+                else {
+                    model[key] = data[key];
+                }
+            }
+        }
+    }
+    static async hydrateRelations(model, relManyData, relOneData, seriesHydrationfields, fullDataMode, data) {
+        // Handle many-to-many relations
+        for (const key in relManyData) {
+            if (!fullDataMode && model.constructor._CUT_KEYS.includes(key)) {
+                continue;
+            }
+            const relMeta = relManyData[key];
+            //  console.log({relMeta});
+            const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(model, relMeta.key);
+            if (relationEnabled) {
+                model[relMeta.key] = await relMeta.inversionModel.findBy({
+                    conditions: {
+                        [relMeta.foreignKey]: data.id
+                    },
+                    allowRelations: false
+                });
+            }
+        }
+        // Handle one-to-one relations
+        for (const key in relOneData) {
+            if (!fullDataMode && model.constructor._CUT_KEYS.includes(key)) {
+                continue;
+            }
+            const relMeta = relOneData[key];
+            const relationEnabled = !RelationUtils_1.RelationUtils.checkRelDisabled(model, relMeta.key);
+            if (!data[relMeta.hydrationField] && relMeta.required) {
+                throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`);
+            }
+            if (relationEnabled && data[relMeta.hydrationField]) {
+                model[relMeta.key] = await relMeta.model.findOneBy({ conditions: { [relMeta.foreignKey]: data[relMeta.hydrationField] } }, { allowRelations: false });
+            }
+            else if (relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]) {
+                const newRelModel = await relMeta.model.create(data[relMeta.key]);
+                model[relMeta.key] = await newRelModel.save();
+            }
+            const cutKeys = model.constructor._CUT_KEYS;
+            const trackedField = Object.keys((await ModelUtils_1.ModelUtils.getModelAnnotations(model.constructor))).includes(relMeta.hydrationField);
+            if (!cutKeys.includes(relMeta.hydrationField) && !trackedField) {
+                cutKeys.push(relMeta.hydrationField);
+            }
+            // seriesHydrationfields.push(relMeta.hydrationField);
+        }
+    }
+}
+exports.HydrateUtils = HydrateUtils;

package/package.json

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

package/src/decorators/InverseRelation.ts

@@ -1,5 +1,6 @@
 import 'reflect-metadata';
 import { RWSModel, OpModelType } from '../models/_model';
+import { ModelUtils } from '../models/utils/ModelUtils';
 
 export interface InverseRelationOpts {
     key: string,
@@ -10,17 +11,57 @@ export interface InverseRelationOpts {
     mappingName?: string
 }
 
+function guessForeignKey(inversionModel: OpModelType<RWSModel<any>>, bindingModel: OpModelType<RWSModel<any>>, decoratorsData: any)
+{
+    let key: string | null = null;
+    let defaultKey = `${bindingModel._collection}_id`;  
+
+    const relDecorators: Record<string, {
+        annotationType: string;
+        metadata: any;
+    }> = {};
+
+    const trackDecorators: Record<string, {
+        annotationType: string;
+        metadata: any;
+    }> = {};
+
+    if(Object.keys(trackDecorators).includes(key)){
+        return key;
+    }
+
+    for(const decKey of Object.keys(decoratorsData)){
+        const dec = decoratorsData[decKey];
+        if(dec.annotationType === 'Relation'){
+            relDecorators[decKey] = dec;
+        }      
+        if(dec.annotationType === 'TrackType'){
+            trackDecorators[decKey] = dec;
+        }                
+    }
+
+    for(const relKey of Object.keys(relDecorators)){
+        const prodMeta = relDecorators[relKey]?.metadata;
+        if(prodMeta && prodMeta.relatedTo._collection === bindingModel._collection){            
+            return prodMeta.relationField;
+        }
+    }
+
+    return key;
+}
+
 function InverseRelation(inversionModel: () => OpModelType<RWSModel<any>>, sourceModel: () => OpModelType<RWSModel<any>>, relationOptions: Partial<InverseRelationOpts> = null) {
     return function (target: any, key: string) {
-        const metadataPromise = Promise.resolve().then(() => {
+        const metadataPromise = Promise.resolve().then(async () => {
             const model = inversionModel();
             const source = sourceModel();
+            const decoratorsData = await ModelUtils.getModelAnnotations(model);           
 
             const metaOpts: InverseRelationOpts = {
                 ...relationOptions,
                 key,
                 inversionModel: model,
-                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : `${source._collection}_id`,
+                foreignKey: relationOptions && relationOptions.foreignKey ? relationOptions.foreignKey : guessForeignKey(model, source, decoratorsData),
                 // Generate a unique relation name if one is not provided
                 relationName: relationOptions && relationOptions.relationName ?
                     relationOptions.relationName.toLowerCase() :

package/src/helper/DbHelper.ts

@@ -1,6 +1,7 @@
 import { IDbConfigHandler, IDbConfigParams, IdGeneratorOptions } from '../types/DbConfigHandler';
 import { OpModelType } from '../models/_model';
 import { DBService } from '../services/DBService';
+import { rwsShell } from '@rws-framework/console';
 
 import {
     DbUtils,
@@ -41,6 +42,14 @@ export class DbHelper {
     static async pushDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
         return SchemaGenerator.pushDBModels(configService, dbService, leaveFile);
     }
+   
+    static async migrateDBModels(configService: IDbConfigHandler, dbService: DBService, leaveFile = false): Promise<void> {
+       process.env = { ...process.env, [this.dbUrlVarName]: configService.get('db_url') };
+       
+        const [_, schemaPath] = DbUtils.getSchemaDir();
+
+        await rwsShell.runCommand(`${DbUtils.detectInstaller()} prisma migrate dev --create-only --schema=${schemaPath}`, process.cwd());
+    }
 
     /**
      * Generate model sections for the schema

package/src/helper/db/schema-generator.ts

@@ -62,7 +62,7 @@ datasource db {
         if(
             !model._NO_ID            
         ){
-            section += `\t${DbUtils.generateId(dbType, modelMetadatas, false)}\n`;
+            section += `\t${DbUtils.generateId(dbType, modelMetadatas)}\n`;
         }              
 
         for (const key in modelMetadatas) {
@@ -108,7 +108,11 @@ datasource db {
                 const relationFieldName = modelMetadata.relationField ? modelMetadata.relationField  : key.toLowerCase() + '_' + modelMetadata.relationField.toLowerCase();
 
                 const relatedToField = modelMetadata.relatedToField || 'id';
-                const bindingFieldExists = !!modelMetadatas[relationFieldName];          
+                const bindingFieldExists = !!modelMetadatas[relationFieldName];  
+                
+                if(modelMetadata.required === false){
+                    requiredString = '?';
+                }
 
                 if (isMany) {
                     // Add an inverse field to the related model if it doesn't exist
@@ -178,21 +182,37 @@ datasource db {
                 }
             } else if (annotationType === 'TrackType') {
                 const trackMeta = modelMetadata as ITrackerMetaOpts;
-                const tags: string[] = trackMeta.tags.map((item: string) => '@' + item);                           
+                const tags: string[] = trackMeta.tags.map((item: string) => '@' + item);  
+                
+                if(key === 'id' && model._NO_ID && !model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes('id'))){
+                    continue;
+                }
        
                 if(trackMeta.unique){
                     const fieldDetail: string | null = typeof trackMeta.unique === 'string' ? trackMeta.unique : null;
                     tags.push(`@unique(${fieldDetail ? `map: "${fieldDetail}"` : ''})`);
                 }
 
+                if(!trackMeta.required){
+                    requiredString = '?';
+                }
+
                 if (trackMeta.isArray || trackMeta.type.name === 'Array') {
                     requiredString = '';
                 }
 
+                if(model._SUPER_TAGS.some(tag => tag.tagType === 'id' && tag.fields.includes(key))){
+                    requiredString = '';
+                }
+
                 // Process any database-specific options from the metadata
                 const dbSpecificTags = TypeConverter.processTypeOptions(trackMeta as { tags: string[], dbOptions: IDbOpts['dbOptions'] }, dbType);
                 tags.push(...dbSpecificTags);
 
+                if(modelName === 'category_translation' && key === 'meta_keywords'){
+                    console.log({requiredString, trackMeta});
+                }
+
                 section += `\t${key} ${TypeConverter.toConfigCase(trackMeta, dbType, key === 'id')}${requiredString} ${tags.join(' ')}\n`;
             }
         }

package/src/helper/db/utils.ts

@@ -40,7 +40,7 @@ export class DbUtils {
     static generateId(
         dbType: IDbConfigParams['db_type'],
         modelMeta: Record<string, { annotationType: string, metadata: IIdMetaOpts }>,
-        debug = false
+        optional = false
     ): string {        
         let useUuid = false;
         let field = 'id';
@@ -53,10 +53,7 @@ export class DbUtils {
             if(key !== 'id'){
                 if(annotationType == 'IdType'){     
                     const dbSpecificTags = TypeConverter.processTypeOptions({ tags: [], dbOptions: modelMetadata.dbOptions }, dbType);
-                    tags.push(...dbSpecificTags);
-                    if(debug){                                     
-                        console.log({modelMetadata: modelMetadata.dbOptions});
-                    }          
+                    tags.push(...dbSpecificTags);                 
                              
                     field = key;
 
@@ -76,29 +73,35 @@ export class DbUtils {
         }
 
         let idString: string;
+        
+        let reqStr = '';
+
+        if(optional){
+            reqStr = '?';
+        }
 
         switch (dbType) {
             case 'mongodb':
-                idString = `${field} String @id @default(auto()) @map("_id") @db.ObjectId`;
+                idString = `${field} String${reqStr} @id @default(auto()) @map("_id") @db.ObjectId`;
                 break;
 
             case 'mysql':
                 idString = useUuid
-                    ? `${field} String @id @default(uuid())`
-                    : `${field} Int @id @default(autoincrement())`;
+                    ? `${field} String${reqStr} @id @default(uuid())`
+                    : `${field} Int${reqStr} @id @default(autoincrement())`;
                 break;
 
             case 'postgresql':
             case 'postgres':
                 idString = useUuid
-                    ? `${field} String @id @default(uuid())`
-                    : `${field} Int @id @default(autoincrement())`;
+                    ? `${field} String${reqStr} @id @default(uuid())`
+                    : `${field} Int${reqStr} @id @default(autoincrement())`;
                     break;    
 
             case 'sqlite':
-                idString = `${field} Int @id @default(autoincrement())`;            
+                idString = `${field} Int${reqStr} @id @default(autoincrement())`;            
                 break;
-        }
+        }        
 
         if(tags.length){
             idString += ' '+tags.join(' ');
@@ -108,9 +111,6 @@ export class DbUtils {
             throw new Error(`DB type "${dbType}" is not supported!`);
         }
 
-        if(debug){                                     
-            console.log({idString, useUuid});
-        }          
 
         return idString;
     }

package/src/models/core/RWSModel.ts

@@ -11,6 +11,9 @@ import { ModelUtils } from '../utils/ModelUtils';
 // import timeSeriesModel from './TimeSeriesModel';      
 import { DBService } from '../../services/DBService';
 import { ISuperTagData } from '../../decorators/RWSCollection';
+import { RelManyMetaType, RelOneMetaType } from '../types/RelationTypes';
+import { IRWSModel } from '../../types/IRWSModel';
+import { HydrateUtils } from '../utils/HydrateUtils';
 
 class RWSModel<T> implements IModel {
     static services: IRWSModelServices = {};
@@ -97,9 +100,7 @@ class RWSModel<T> implements IModel {
     }
 
     public async _asyncFill(data: any, fullDataMode = false, allowRelations = true): Promise<T> {
-        const collections_to_models: {[key: string]: any} = {};           
-        const timeSeriesIds = TimeSeriesUtils.getTimeSeriesModelFields(this);
-    
+        const collections_to_models: {[key: string]: any} = {};               
         const classFields = FieldsHelper.getAllClassFields(this.constructor);        
     
         // Get both relation metadata types asynchronously
@@ -113,92 +114,19 @@ class RWSModel<T> implements IModel {
         });      
     
         const seriesHydrationfields: string[] = []; 
-        
-        if (allowRelations) {
-            // Handle many-to-many relations
-            for (const key in relManyData) { 
-                if(!fullDataMode && (this as any).constructor._CUT_KEYS.includes(key)){
-                    continue;
-                }
 
-                const relMeta = relManyData[key];  
-        
-                const relationEnabled = !RelationUtils.checkRelDisabled(this, relMeta.key);
-                if (relationEnabled) {                                
-                    this[relMeta.key] = await relMeta.inversionModel.findBy({
-                        conditions: {
-                            [relMeta.foreignKey]: data.id
-                        },
-                        allowRelations: false
-                    });    
-                }                                
-            }
-            
-            // Handle one-to-one relations
-            for (const key in relOneData) {      
-                if(!fullDataMode && (this as any).constructor._CUT_KEYS.includes(key)){
-                    continue;
-                }
 
-                const relMeta = relOneData[key];          
-                const relationEnabled = !RelationUtils.checkRelDisabled(this, relMeta.key);
-                
-                if(!data[relMeta.hydrationField] && relMeta.required){
-                    throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`)
-                }
-                
-                if (relationEnabled && data[relMeta.hydrationField]) {        
-                    this[relMeta.key] = await relMeta.model.find(data[relMeta.hydrationField], { allowRelations: false });    
-                }                                
-                else if(relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]){                    
-                    const newRelModel: RWSModel<any> = await relMeta.model.create(data[relMeta.key]);                    
-                    this[relMeta.key] = await newRelModel.save();
-                }
-
-                const cutKeys = ((this.constructor as any)._CUT_KEYS as string[]);
-
-                if(!cutKeys.includes(relMeta.hydrationField)){
-                    cutKeys.push(relMeta.hydrationField)
-                }
-            }
+        if (allowRelations) {
+            await HydrateUtils.hydrateRelations(this, relManyData, relOneData, seriesHydrationfields, fullDataMode, data);
         }
     
         // Process regular fields and time series
-        for (const key in data) {
-            if (data.hasOwnProperty(key)) {                        
-                if(!fullDataMode && (this as any).constructor._CUT_KEYS.includes(key)){
-                    continue;
-                }
-
-                if (Object.keys(relOneData).includes(key)) {               
-                    continue;
-                }                
-    
-                if (seriesHydrationfields.includes(key)) {
-                    continue;
-                }                    
-    
-                const timeSeriesMetaData = timeSeriesIds[key];  
-          
-                if (timeSeriesMetaData) {
-                    this[key] = data[key];
-                    const seriesModel = collections_to_models[timeSeriesMetaData.collection];
-            
-                    const dataModels = await seriesModel.findBy({
-                        id: { in: data[key] }
-                    });                        
-    
-                    seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
-            
-                    this[timeSeriesMetaData.hydrationField] = dataModels;
-                } else {
-                    this[key] = data[key];            
-                }        
-            }       
-        }     
+         await HydrateUtils.hydrateDataFields(this, collections_to_models, relOneData, seriesHydrationfields, fullDataMode, data);
     
         return this as any as T;
-    }    
+    }   
+
+    
 
     private getModelScalarFields(model: RWSModel<T>): string[] {
         return ModelUtils.getModelScalarFields(model);
@@ -411,7 +339,7 @@ class RWSModel<T> implements IModel {
 
     public static async find<T extends RWSModel<T>>(
         this: OpModelType<T>,
-        id: string,        
+        id: string | number,        
         findParams: Omit<FindByType, 'conditions'> = null
     ): Promise<T | null> {        
         const ordering = findParams?.ordering ?? null;
@@ -445,12 +373,15 @@ class RWSModel<T> implements IModel {
         const collection = Reflect.get(this, '_collection');
         this.checkForInclusionWithThrow(this.name);
         try {
-            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering);   
+            const paginateParams =  findParams?.pagination ? findParams?.pagination : undefined;
+            const dbData = await this.services.dbService.findBy(collection, conditions, fields, ordering, paginateParams);        
+
             if (dbData.length) {
                 const instanced: T[] = [];
         
                 for (const data of dbData) { 
                     const inst: T = new (this as { new(): T })();
+
                     instanced.push((await inst._asyncFill(data, fullData,allowRelations)) as T);
                 }
         

package/src/models/interfaces/OpModelType.ts

@@ -27,7 +27,7 @@ export interface OpModelType<T> {
     ): Promise<T | null>;
     find<T extends RWSModel<T>>(
         this: OpModelType<T>,
-        id: string,        
+        id: string | number,        
         findParams?: Omit<FindByType, 'conditions'>
     ): Promise<T | null>;
     findBy<T extends RWSModel<T>>(

package/src/models/utils/HydrateUtils.ts

@@ -0,0 +1,102 @@
+import { RWSModel } from "../core/RWSModel";
+import { RelManyMetaType, RelOneMetaType } from "../types/RelationTypes";
+import { IRWSModel } from "../../types/IRWSModel";
+import { TimeSeriesUtils } from "./TimeSeriesUtils";
+import { RelationUtils } from "./RelationUtils";
+import { OpModelType } from "..";
+import { ModelUtils } from "./ModelUtils";
+
+export class HydrateUtils {
+    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);
+        for (const key in data) {         
+                    if (data.hasOwnProperty(key)) {                   
+                        if(!fullDataMode && ((model).constructor as OpModelType<any>)._CUT_KEYS.includes(key)){
+                            continue;
+                        }
+        
+                        if (Object.keys(relOneData).includes(key)) {               
+                            continue;
+                        }                
+            
+                        if (seriesHydrationfields.includes(key)) {
+                            continue;
+                        }                   
+                      
+            
+                        const timeSeriesMetaData = timeSeriesIds[key];  
+                  
+                        if (timeSeriesMetaData) {
+                            model[key] = data[key];
+                            const seriesModel = collections_to_models[timeSeriesMetaData.collection];
+                    
+                            const dataModels = await seriesModel.findBy({
+                                id: { in: data[key] }
+                            });                        
+            
+                            seriesHydrationfields.push(timeSeriesMetaData.hydrationField);
+                    
+                            model[timeSeriesMetaData.hydrationField] = dataModels;
+                        } else {
+                            model[key] = data[key];            
+                        }        
+                    }       
+                }    
+     }
+
+     static async hydrateRelations(model: RWSModel<any>, relManyData: RelManyMetaType<IRWSModel>, relOneData: RelOneMetaType<IRWSModel>, seriesHydrationfields: string[], fullDataMode: boolean, data: {[key: string] : any})
+         {
+             // Handle many-to-many relations
+             for (const key in relManyData) { 
+                 if(!fullDataMode && (model as any).constructor._CUT_KEYS.includes(key)){
+                     continue;
+                 }
+     
+                 const relMeta = relManyData[key];  
+
+                //  console.log({relMeta});
+         
+                 const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
+                 if (relationEnabled) {                                
+                    model[relMeta.key] = await relMeta.inversionModel.findBy({
+                         conditions: {
+                             [relMeta.foreignKey]: data.id
+                         },
+                         allowRelations: false
+                     });    
+                 }                                
+             }
+             
+             // Handle one-to-one relations
+             for (const key in relOneData) {      
+                 if(!fullDataMode && ((model as any).constructor as OpModelType<any>)._CUT_KEYS.includes(key)){
+                     continue;
+                 }
+     
+                 const relMeta = relOneData[key];          
+                 const relationEnabled = !RelationUtils.checkRelDisabled(model, relMeta.key);
+                 
+                 if(!data[relMeta.hydrationField] && relMeta.required){
+                     throw new Error(`Relation field "${relMeta.hydrationField}" is required in model ${this.constructor.name}.`)
+                 }
+                                  
+                 if (relationEnabled && data[relMeta.hydrationField]) {                        
+                    model[relMeta.key] = await relMeta.model.findOneBy({conditions: {[relMeta.foreignKey] : data[relMeta.hydrationField]}}, { allowRelations: false });    
+                 }                                
+                 else if(relationEnabled && !data[relMeta.hydrationField] && data[relMeta.key]){                    
+                     const newRelModel: RWSModel<any> = await relMeta.model.create(data[relMeta.key]);                    
+                     model[relMeta.key] = await newRelModel.save();
+                 }
+     
+                 const cutKeys = ((model.constructor as OpModelType<any>)._CUT_KEYS as string[]);
+     
+                 const trackedField = Object.keys((await ModelUtils.getModelAnnotations(model.constructor as OpModelType<any>))).includes(relMeta.hydrationField);
+                 
+                 if(!cutKeys.includes(relMeta.hydrationField) && !trackedField){
+                     cutKeys.push(relMeta.hydrationField)
+                 }
+     
+                 // seriesHydrationfields.push(relMeta.hydrationField);
+             }
+         }
+}